文章目录
一、构造方法
含义：与类名形同，且没有返回项的方法
作用：
创建对象（new 构造方法() 创建对象）
初始化数据
注意：没有参数的构造方法叫做无参构造，当没有其他有参构造时，系统会默认实现
构造方法 vs 普通方法（成员方法和静态方法）
构造方法：必须和类名相同且没有返回项
普通方法：必须有返回项（不管是返回具体的值还是void）
人类
package com.dream.test01;
public class Person {
String name;
char sex;
int age;
public Person(){
}
public Person(String name,char sex,int age){
this.name = name;
this.sex = sex;
this.age = age;
}
public void eat(){
System.out.println(this.name + "吃饭饭");
}
public void sleep(){
System.out.println(this.name + "睡觉觉");
}
}
测试类
package com.dream.test01;
public class Test01 {
public static void main(String[] args) {
/**
* 构造方法的知识点
*
* 创建对象的语法：
* 数据类型 引用/变量 = new 构造方法();
*
* 含义：与类名相同且没有返回项的方法叫做构造方法
*
* 注意：该类没有有参构造时，会自动生成无参构造
*
* 作用：
* 1.和new 一起创建对象
* 2.初始化数据
*/
Person p1 = new Person("杨晨", '男', 18);
System.out.println(p1.name);
p1.eat();
p1.sleep();
Person p2 = new Person("麻生希", '女', 23);
System.out.println(p2.name);
p2.eat();
p2.sleep();
}
}
二、private
含义：私有化
作用：
修饰属性：私有化属性，外界不能被调用
修饰方法：私有化方法，外界不能被调用
外界：类的外面
应用场景：
如果当前类的属性不想让外界调用，就用private修饰
如果当前类的方法不想让外界调用，就用private修饰
A类
package com.dream.test02;
public class A {
private String str;
private void method(){
System.out.println("aaaa");
}
}
测试类
package com.dream.test02;
public class Test01 {
public static void main(String[] args) {
/**
* private私有化
*/
A a = new A();
//私有化属性后，不能被外界调用
// a.str = "xxx";
// System.out.println(a.str);
//私有化方法后，不能被外界调用
// a.method();
}
}
三、封装
好处：避免直接操作属性，可以在set/get方法中做额外的功能
步骤：
私有化属性
添加get/set方法
人类
package com.dream.test03;
public class Person {
private String name;
private char sex;
private int age;
public Person(){
}
public Person(String name,char sex,int age){
this.name = name;
this.sex = sex;
this.age = age;
}
public String getName(){
return name;
}
public void setName(String name){
this.name = name;
}
public char getSex() {
return sex;
}
public void setSex(char sex) {
this.sex = sex;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public void eat(){
System.out.println(this.name + "吃饭饭");
}
public void sleep(){
System.out.println(this.name + "睡觉觉");
}
}
测试类
package com.dream.test03;
public class Test01 {
public static void main(String[] args) {
/**
* 封装
*
* 步骤：
* 1.私有化属性
* 2.添加get/set方法
*/
Person p1 = new Person("杨晨", '男', 18);
p1.setName("陈希");
System.out.println(p1.getName());
}
}
四、小结
编写一个类的步骤：
编写属性，并用private私有化
创建无参构造和有参构造
添加get/set方法
添加其他方法
为什么私有化属性？
不想让外界随便调用，考虑到数据的安全性
为什么添加无参构造和有参构造？
添加有参构造的目的方便在创建对象时就初始化数据，但是编写了有参构造，系统就不会默认实现无参构造，所以自己还要去写一个无参构造
为什么添加get/set方法？
因为私有化属性后，使用get/set方法对外提供获取和设置的功能，还可以额外添加功能
五、this
含义：本对象
作用：
this.属性：调用本对象属性
this.方法：调用本对象方法
this() : 调用本对象构造方法
人类
package com.dream.test04;
public class Person {
private String name;
private char sex;
private int age;
public Person() {
this("默认姓名",'男',18);
}
public Person(String name, char sex, int age) {
this.name = name;
this.sex = sex;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public char getSex() {
return sex;
}
public void setSex(char sex) {
this.sex = sex;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public void eat(){
System.out.println(this.name + "吃饭饭");
this.sleep();
}
public void sleep(){
System.out.println(this.name + "睡觉觉");
}
}
测试类
package com.dream.test04;
public class Test01 {
public static void main(String[] args) {
/**
* this：本对象
*
* 作用：
* 1.this.属性：调用本对象的成员属性
* 2.this.方法：调用本类的成员方法
* 3.this()：调用本类的构造方法(this()只能写在构造方法的第一句)
*
*/
Person p1 = new Person("杨晨", '男', 18);
Person p2 = new Person("陈希", '男', 23);
Person p3 = new Person();
System.out.println(p3.getName());
System.out.println(p3.getSex());
System.out.println(p3.getAge());
}
}
六、分包
基本的好处：防止了类的重名
项目中的好处：项目中有很多类，类的功能也不一样，可以把相似的类放在一个包里
七、static(上)
含义：静态的
作用：
修饰属性：类属性/静态变量，直接用类名调用，该类的每个对象共享一份
静态变量的生命周期：
- 在类加载到方法区时，系统会扫描该类的静态变量并存放在静态区中
- 项目结束时，静态区中的数据才会被回收
应用场景：static + final(下周去学习)
A类
package com.dream.test05;
public class A {
String str1;
//准备阶段1：String str2;
//准备阶段2：String str2 = null;
//初始化阶段：String str2 = "静静";
static String str2 = "静静";
//准备阶段：String str3;
//准备阶段：String str3 = "涵涵";
static final String str3 = "涵涵";
}
测试类
package com.dream.test05;
public class Test01 {
public static void main(String[] args) {
/**
* static修饰属性
*/
A a1 = new A();
A a2 = new A();
a1.str1 = "xxx";
a2.str1 = "yyy";
System.out.println(a1.str1);//xxx
System.out.println(a2.str1);//yyy
// a1.str2 = "aaa";
// a2.str2 = "bbb";
// System.out.println(a1.str2);//bbb
// System.out.println(a2.str2);//bbb
A.str2 = "aaa";
A.str2 = "bbb";
System.out.println(A.str2);
}
}
package com.dream.test06;
public class Test01 {
public static void main(String[] args) {
/**
* static修饰属性的面试题/类加载机制的面试题
*/
A a = A.getInstance();
System.out.println("A value1:" + A.value1);//1
System.out.println("A value2:" + A.value2);//0
B b = B.getInstance();
System.out.println("B value1:" + B.value1);//1
System.out.println("B value2:" + B.value2);//1
}
}
class A{
//A a = new A();
//int value1 = 1;
//int value2 = 0;
private static A a = new A();
public static int value1;
public static int value2 = 0;
private A(){
value1++;
value2++;
}
public static A getInstance(){
return a;
}
}
class B{
//int value1 = 1;
//int value2 = 1;
//B b = new B();
public static int value1;
public static int value2 = 0;
private static B b = new B();
private B(){
value1++;
value2++;
}
public static B getInstance(){
return b;
}
}