本章将复盘类与对象的学习，内容较多，建议反复观看视频
一、什么是面向对象？
面向对象是解决问题的一种思想，主要通过与对象之间的交互来实现一件事情
面向过程恰恰与之相对，就以洗衣服为例：
启动洗衣机来完成洗衣服叫面向对象，用户只关心是洗衣机这个对象洗干净了衣服
洗衣服的过程如烘干、脱水等叫面向过程
二、什么叫类？
类就相当于对一个对象进行描述，好比洗衣机各种性能的描述(大小、功率、长度、高度等等)
它的属性被定义出来以后叫做成员变量，它要实现的功能定义出来叫做成员方法
class WashMashine{
//成员变量
public int length;
public int hight;
public String type;
//成员方法
public void washcloth{
System.out.println("洗衣功能");
}
public void drycloth{
System.out.println("烘干功能");
}
}注意：
1、此处定义的方法没有加static，这个后面会解释
2、一个文件里最好只创建一个类
三、类的实例化
上面通过class相当于是定义出了一个类的模板，接下来我们要对其实例化，也就是用类的类型创建对象的过程
1、如何实例化
public class java0530 {
public static void main(String[] args) {
int a = 10;
Dog dog1 = new Dog();
Dog dog2 = new Dog();
}
}
比如上面这样做就是定义了一个Dog类型的变量
2、如何访问对象中的成员
class Dog {
//成员变量
public int age;
public String type;
public String name;
//成员方法
public void bark() {
System.out.println(name + "在汪汪汪");
}
public void sleep() {
System.out.println(name + "在睡觉");
}
}public class java0530 {
public static void main(String[] args) {
int a = 10;
Dog dog1 = new Dog();
dog1.name = "旺财";
dog1.type = "金毛";
dog1.age = 10;
dog1.bark(); //调用成员方法
Dog dog2 = new Dog();
}
}
这里就是通过变量名后加.的方式进行赋值，成员方法也是如此
应用：两个实参值的交换
public class java0601 {
public static void swap(Dog a, Dog b){
int temp =a.num;
a.num= b.num;
b.num=temp;
}
public static void main(String[] args) {
Dog a = new Dog();
a.num = 80;
Dog b = new Dog();
b.num = 40;
System.out.println(a.num+" "+b.num);
swap(a,b);
System.out.println(a.num+" "+b.num);
}
}注意这里的Dog中定义的变量类型不应该为static，否则会交换失败
四、this关键字
this起到一个指向当前对象的作用，可以理解成谁调用成员方法，谁就是this对象
class Dog {
//成员变量
public static int age;
public static String type;
public static String name;
//成员方法
public void setDog(int a, String t, String n){
this.age = a;
this.type = t;
this.name = n;
}public class java0530 {
public static void main(String[] args) {
Dog dog1 = new Dog();
dog1.setDog(10, "金毛", "旺财");
dog1.printDog();
}
}这几行代码起到不用一个个给成员变量赋值的作用
这里如果成员变量和形参名字相同并且刚好没有this时，那就相当与形参自己给自己赋值，最后结果是0
总结：this的作用
1、this. 成员变量 // 访问对象的成员变量
2、this. 成员方法 // 访问对象的成员方法
3、this.() //调用其他构造方法
五、对象的构造及初始化
构造方法是一种特殊的方法，没有返回值，并且方法名和类名一样
它的主要目的就是初始化成员变量
class Dog {
//成员变量
public static int age;
public static String type;
public static String name;
//构造方法
public Dog(int a,String b,String c){
this.age = a;
this.type = b;
this.name = c;
}
}public class java0601 {
public static void main(String[] args) {
Dog dog3 = new Dog(10,"旺财","金毛");
Dog.printDog();
}
在你没有创建一个构造方法之前，编译器为自动给你一个不带参数的构造方法
这个过程就是在你new一个对象的时候开始的
一旦有了一个构造方法，编译器就不再提供了（有用的一句话）
六、封装
将数据和操作数据的方法进行有机结合，隐藏对象的属性的实现细节，
进对外公开接口来对对象进行交互
面向对象程序的三大特性：封装，继承，多态
来看下面这两段代码：
package bit;
public class demo1 {
private int age;
private String name;
public demo1(int age, String name) {
this.age = age;
this.name = name;
}
public String getname(){
return this.name;
}
public void setname(String name){
this.name = name;
}
}package bit;
public class demo2 {
public static void main(String[] args) {
demo1 student = new demo1(15,"张三");
student.setname("李四");
System.out.println(student.getname()); //通过调用来访问封装的成员变量
}
}
这就是一个简单的封装手段，通过private让成员变量只能在本类名以内被调用，如果想使用就通过引用方法
七、static静态变量
1、static修饰成员变量
在成员变量前加static就是静态成员变量，此时的静态成员变量就不在堆上了，因此不依赖于对象（不用实例化对象），直接使用 类名.静态成员变量 就可以进行访问
public class demo1 {
private int age;
private String name;
public static String classroom;
public demo1(int age, String name) {
this.age = age;
this.name = name;
}
}public class demo2 {
public static void main(String[] args) {
demo1 student = new demo1(15,"张三");
demo1.classroom = "16班";
System.out.println(demo1.classroom);
}
}注意：
此时这个成员变量就只有一份了
引用对象强行访问不会报错，但它本身并不合理
2、static修饰成员方法
同样的，要想调用这个静态成员方法，也是采取类名.静态成员方法的形式
public class demo1 {
private int age;
private String name;
public static String classroom;
public demo1(int age, String name) {
this.age = age;
this.name = name;
}
public void Function1(){
System.out.println("非静态成员变量");
}
public static void Function2(){
System.out.println("静态成员变量");
demo1 student1 = new demo1(13,"李四");
student1.Function1();
}
}public class demo2 {
public static void main(String[] args) {
demo1.Function2();
}
}
这里需要着重注意的点是：
1、在一个静态成员方法中不可以调用一个非静态成员方法，如果非要调用则需要在其内部加入这个非静态成员方法所引用的对象
2、同样的，在方法中调用对象也是如此
3、静态方法中不能使用this（因为静态方法不依赖对象，不确定this到底是谁）
八、代码块（发现看不懂就火速复习）
执行顺序：1、静态代码块（都是静态就按顺序执行）
2、实例化代码块（都是实例化就按顺序执行）
3、构造代码块
那个静态代码块则是在类被加载时才会执行：
上面这个程序的执行结果就是：
因为在实例化第一个对象时类就被加载了一次，后面没有加载了
