【Java】类和对象，封装
目录
1.类和对象的定义
2.关键字new
3.this引用
4.对象的构造及初始化
5.封装
//包的概念
//如何访问
6.static成员
7.代码块
8.对象的打印
1.类和对象的定义
对象：Java中一切皆对象。
类：一般情况下一个Java文件一个类，每一个类对应一个字节码文件（*.class）
1）字段 / 属性 / 成员变量：定义在类中，方法的外面；2）方法
类似于C语言的结构体。
成员变量未初始化时都有一个默认值：引用类型默认值为null；int类型默认值为0；float类型默认值为0.0f；char类型默认值为'\u0000'；boolean类型默认值为false
class WashMachine{//类//字段/属性/成员变量public String brand;public String type;public double weight;public double length;public double height;public String color;//成员方法public void washClothes(){System.out.println("洗衣功能");}public void dryClothes(){System.out.println("脱水功能");}public void setTime(){System.out.println("定时功能");}
}注意：
1> idea中如何打开当前类所在文件夹：*. java + 右键 +Open in + Explorer;
2> 当类由public修饰时，类名必须和文件名一致；
3> 不要轻易去修改public修饰的类的名称，若要修改:文件名 + 右键 + Refactor + Rename；
4> 类中的方法不需要static修饰。
2.关键字new
public static void main(String[] args) {WashMachine washmachine1 = new WashMachine();WashMachine washmachine2 = new WashMachine();//赋值washmachine1.brand = "海尔";washmachine2.brand = "小天鹅";//washmachine：引用变量，存了对象的地址——>实例化对象System.out.println(washmachine1.brand);System.out.println(washmachine2.brand);washmachine1.washClothes();washmachine2.washClothes();
}注意：
1> 可以使用关键字new实例化多个对象；
2> 同一个类可以创建多个实例；
3> 使用 . 来访问对象中的属性和方法。
3.this引用
public class TestDate {public int year;public int month;public int day;public void setDate(int y,int m,int d){//谁调用了setDate，this就是谁this.year = y;this.month = m;this.day = d;}public void printDate(){//要习惯加上thisSystem.out.println(this.year+"年"+this.month+"月"+this.day+"日");}public static void main(String[] args) {//main方法可以定义在类当中//定义TestDate testDate1 = new TestDate();TestDate testDate2 = new TestDate();TestDate testDate3 = new TestDate();//赋值testDate1.setDate(2000,2,28);testDate2.setDate(2022,12,21);testDate3.setDate(2023,3,12);//打印testDate1.printDate();testDate2.printDate();testDate3.printDate();}
}
注意：
1> this对应类型引用，哪个对象调用就是哪个对象的引用类型；
2> this只能在普通成员方法中使用，静态成员方法（static修饰）中不能使用；
3> 在成员方法中，this只能引用当前对象，不能再引用其他对象；
4> this时成员方法第一个隐藏的参数，编译器会自动传递。
4.对象的构造及初始化
普通方法：返回值+方法名+（参数列表）+ {方法体}
构造方法：没有返回值且方法名必须和类名保持一致
//注意方法名与类名一致！！！
public TestDate(){System.out.println("没有参数的构造方法");
}
public TestDate(int year,int month,int day){ //两个方法构成了重载this.year = year;this.month = month;this.day = day;System.out.println("有3个参数的构造方法");
}注意：
1> 构造方法可以重载（方法名均为类名）；
2> 构造方法一个都没写的情况下，编译器会帮你默认生成一个不带参数的构造方法；但当你写了其中任意一种构造方法，其它构造方法编译器不会帮你生成；
3> 构造方法一定会被调用，具体调用哪个构造方法得看有没有相应的参数；
3> 一个对象的产生至少有以下2步：为对象分配内存，调用合适的构造方法；
4> idea自动生成构造方法：右键 + Generate + Constructor + 自选；
5> 可在构造方法中使用this()来调用另一个构造方法且必须放在第一行，但是不能自己调用自己 。
class Student{public String name;public int age;public Student(){ //此为没有参数的构造方法this("wangwu",20);//this()必须放在第一行System.out.println("调用第一个");this.print();//利用this调用其他成员方法，可以不放在第一行}public Student(String name,int age){//此为有两个参数的构造方法this.name = name;this.age = age;System.out.println("调用第二个");}public void print(){System.out.println("姓名："+this.name+"年龄："+this.age);//注意这里不加this输出 姓名：null年龄：0}
}
public class Test {public static void main(String[] args) {Student student1 = new Student();//调用上面第一个构造函数student1.name = "zhangsan";student1.age = 18;Student student2 = new Student("lisi",19);//调用上面第二个构造函数student2.print();}
}
5.封装
面向对象程序三大特性：封装、继承、多态。这里先介绍封装的概念。
定义：将类的实现细节进行隐藏，类外看不见数据，实现了类的安全性。
注意：defaule是什么都不写时的默认权限
| No | 范围 | private | default | protected | public |
|---|---|---|---|---|---|
| 1 | 同一包中的同一类 | √ | √ | √ | √ |
| 2 | 同一包中的不同类 | × | √ | √ | √ |
| 3 | 不同包中的子类 | × | × | √ | √ |
| 4 | 不同包中的非子类 | × | × | × | √ |
//包的概念
定义：多个类收集在一起成为一组，称为软件包，类似于目录。
导入：可以让编译器自动导入，也可以手动导入。
通配符*：可以充当任何类。如util.* 不是导入util下的所有类，而是用到哪个类就用哪个类。
但是当使用的类在多个包中都有时，需要手动导入。非必要不用*。
自定义包：在文件最上方加上一个package语句指定改代码在哪个包中。
//如何访问
前面我们说了用private修饰之后，类外就不能使用类内的变量了，那无法访问有什么意义呢？别急，强大的idea可以帮我们用另一种方法访问：
class Student{private String name;//私有，无法在类外访问private int age;//同上public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}
}
public class Test {public static void main(String[] args) {Student student = new Student();student.setName("wangwu");//利用setName和getName访问System.out.println(student.getName());student.setAge(20);System.out.println(student.getAge());}
}6.static成员
特点：1）修饰成员变量或方法，称为类变量/静态成员变量或类方法，不能修饰局部变量；
2）不依赖对象，不需要new对象，所有对象共用一份；
3）静态方法内部不能调用非静态方法，不能使用this，无法重写；
4）存储在方法区当中，生命周期伴随类的一生。
访问方式：虽然可以但是不建议通过对象来引用访问，而是通过类名访问。
class Student{private String name;//普通成员变量，每个对象都有一份private int age;//普通成员变量public static String classroom = "301";//被static修饰，称为类变量/静态成员变量，所有对象共用一份public Student(String name, int age) {this.name = name;this.age = age;}public static void func() {System.out.println("func……");}
}
public class Test {public static void main(String[] args) {Student student1 = new Student("zhangsan",20);Student student2 = new Student("lisi",21);Student student3 = new Student("wangwu",22);//这些对象都可以不new，不影响类变量和类方法的调用/*System.out.println("教室是"+student1.classroom);//结果是一样的System.out.println("教室是"+student2.classroom);System.out.println("教室是"+student3.classroom);*///虽然可以但是不建议通过对象来引用访问System.out.println("教室是"+Student.classroom);//而是通过类名直接访问;Student.func();}
}7.代码块
分类：静态代码块，实例代码块，同步代码块，普通代码块
注意：
1）顺序：静态代码块 > 构造代码块 > 构造方法 ；
2）静态代码块不管生成多少个对象，都只执行一次；
3）如果一个类中包含多个静态代码块，编译器会按照顺序依次执行。
class Student {private String name = "lisi";private int age;{this.name = "zhangsan";//按顺序执行这一行代码，名字为zhangsanSystem.out.println("构造块！");}static {classroom = "201";System.out.println("静态代码块！");}public static String classroom = "208";//按顺序执行这一行代码，班级为208public Student() {System.out.println("调用不带参数的构造方法！");}public Student(String name, int age) {this.name = name;this.age = age;System.out.println("调用带两个参数的构造方法！");}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}
}
public class Test {public static void main(String[] args) {Student student = new Student();System.out.println(Student.classroom);//208System.out.println(student.getName());//zhangsan}
}
8.对象的打印
编译器自己生成（方法重写）：右键 + Generate + toString() + 自选
class Student {public String name;public int age;public Student(String name, int age) {this.name = name;this.age = age;}@Override//方法重写，重写了toString方法public String toString() {return "Student{" +"name='" + name + '\'' +", age=" + age +'}';}public void print() {System.out.println("姓名:"+this.name+" 年龄："+this.age);}
}
public class Test {public static void main(String[] args) {Student student = new Student("zhangsan",20);System.out.println(student);//没重写时，打印student的地址student.print();//正常调用上面的成员方法}
}
Over！继承和多态见！！