类和对象

类：对象共同特征的描述
对象：真实存在的东西

定义类

一个java文件中可以定义多个类，但是只能一个类是public修饰，public修饰的类名必须是Java代码的文件名。

public class 类名 {
	1.成员变量
	2.成员方法
	3.构造器
	4.代码块
	5.内部类
}

JavaBean类

在JavaBea类中不写main方法，用来描述一类事物
标准的JavaBean：

类名见名知意
成员变量使用private修饰
至少提供两个构造方法（无参、带全部参数）
提供每一个成员变量对应的get和set方法

测试类

创建javaBean类的对象并复制调用，带main方法

封装

对象代表什么，就得封装对应的数据，并提供数据对应的行为。
例：人画圆：画圆这个方法应该是定义在圆类里边。【人调用了圆类中画圆的方法】

构造方法

在创建对象的时候给成员变量进行初始化的。
执行时机：创建对象的时候由虚拟机调用。

public class Stu {
	修饰符 类名(参数) {
		方法体;
	}
}

方法名和类名相同

没有返回值（不能有return待会结果数据）

如果没有写构造方法，虚拟机会默认给一个空参的构造方法。

如果已经定义了构造方法，虚拟机就不会给空参的构造方法。

推荐：无论是否使用，把无参构造和带全部参数的构造都写上。

对象内存图

虚拟机创建一个对象的过程

Student s = new Student()

加载class文件
申明局部变量
在堆内存中开辟空间
默认初始化
显式初始化
构造方法初始化
将堆内存中的地址值赋值给左边的局部变量

一个对象的内存图

两个对象的内存图

两个引用指向同一个对象

基本数据类型和引用数据类型

基本数据类型：数据值存在自己的空间，赋值给其他变量，也是赋的真实的值
引用数据类型：数据值存储在其他空间，自己的空间存储的是其他空间的地址值。

this的内存原理

this：区分局部变量和成员变量。
本质：所在方法调用者的地址值。

static

修饰成员变量（静态变量）

特点：该类被所有对象共享
调用方式：类名调用、对象名调用

静态变量是随着类的加载而加载，属于类，不属于对象。

修饰成员方法（静态方法）

特点：多用于测试类和工具类中，javaBean中很少用
调用方式：类名调用、对象调用

静态方法只能访问静态变量和静态方法
非静态方法可以访问所有的变量和方法（静态、非静态）
静态方法中没有this关键字【非静态方法虚拟机会分配一个this对象，表示当前方法调用者的地址，这个this不需要我们来赋值】

工具类

需要私有化构造方法（工具类的对象没有实际意义，可以通过类名直接调用工具类里的方法）
方法定义为静态的

继承

继承的特点

java只支持单继承，不支持多继承，但支持多层继承
所有的类都直接或间接继承于Object类

子类能继承父类的东西

构造方法

父类的构造方法不能被子类继承

构造方法的访问特点

父类中构造方法不会被子类继承
子类中所有的构造方法都先默认访问父类中的无参构造，再执行自己。
子类构造方法的第一行默认都是：**super()**，不写虚拟机也会自动加上。

成员变量

私有和非私有的都可以直接继承，但是私有的成员变量不能被直接使用。

成员方法

只有父类中的虚方法才能被子类继承

虚方法表

非private、非static、非final

作用：提高程序的性能、

方法重写

重写方法、形参列表和父类一致
方法的访问权限子类访问权限必须大于等于父类
方法的返回值类型子类必须小于等于父类
只有被添加到虚方法表中的方法才能被重写

this、super使用总结

this：一个变量，表示当前方法调用者的地址（并不是每个对象里都有this）
super：表示父类存储空间

注意：如果使用this(…)访问本类其他构造，虚拟机就不会再添加super()了，因为this(…)访问的构造方法里就会自动加上super()

多态

多态：对象的多种表现形态

变量调用：编译看左边，运行看左边。
方法调用：编译看左边，运行看右边。

class Animal {
    String name = "动物";
    public void show() {
        System.out.println("animal show()...");
    }
}
class Dog extends Animal {
    String name = "狗";
    public void show() {
        System.out.println("dog show()...");
    }
}
public class Demo01 {
    public static void main(String[] args) {
        Animal a = new Dog();
        /**
         * 调用成员变量：编译看左边，运行看左边
         * 编译看左边：javac编译时，会看左边的父类中有没有这个变量，如果有，编译成功；没有，编译报错。
         * 运行看左边：java运行时，实际获取的就是左边父类中成员变量的值。
         */
        System.out.println(a.name); // 动物
        /**
         * 调用成员方法：编译看左边，运行看右边
         * 编译看左边：javac编译时，会看左边的父类中有没有这个变量，如果有，编译成功；没有，编译报错。
         * 运行看右边：java运行代码时，实际上运行的事子类中的方法
         */
        a.show();// dog show()...
    }
}

理解：
Animal a = new Dog();
a是Animal类的，所以默认都会从Animal这个类中找。
成员变量：在子类对象中，会把父类中的成员变量也继承下来。
成员方法：如果子类重写方法，在虚方法表中会把父类中的方法进行覆盖。

多态的优势

右边可以实现解耦合
定义方法时，使用父类作为参数，可以接受所有的子类对象。

多态的弊端

不能调用子类特有的方法【通过强转成子类来调用子类特有的方法】

包

包就是文件夹，管理不同功能的Java类。
类的全类名 = 包名 + 类名

使用其他类的规则

使用同一个包中的类，不需要导包
使用java.lang包中的类，不需要导包
其他情况都需要导包
如果使用两个包中同名的类，需要导包

final

可以修饰方法、类、变量

修饰方法：表明当前方法是最终方法，不能被重写【当前的方法是一种规则，不希望别人去改变】
修饰类：表明当前方法是最终类，不能被继承
修饰变量：被修饰的变量叫做常量，只能被赋值一次

final修饰的变量是基本类型：变量存储的数据值不能发生改变。
final修饰的变量是引用类型：变量存储的地址值不能发生改变，对象的内部可以改变。

权限修饰符

控制一个成员可以被访问的范围，可以修饰方法、变量、构造方法、内部类
private < 缺省 < protected < public

代码块

局部代码块（淘汰）
构造代码块：写在成员位置的代码，优先于构造方法执行，可以把多个构造方法中重复的代码写在构造代码块中（淘汰）

public class Student {
	private String name;
	{// 构造代码块，先于构造方法执行
		System.out.print("开始创建对象了");
	}
	public Student() {
		
	}
	public Student(String name) {
		this.name = name;
	}
}

常用：

3. 静态代码块
需要通过static关键字修饰，随着类的加载而加载，自动触发，只执行一次。
格式：static{}
使用场景：在类加载的时候，做一些数据初始化的时候使用

class Stu {
    private String name;
    private int age;
    static {
        System.out.println("静态代码块执行了");
    }
}
public class Demo03 {
    public static void main(String[] args) {
        Stu stu1 = new Stu();
        Stu stu2 = new Stu();
    }
}

抽象类

将共性的方法抽象到父类之后，在父类中不确定具体的方法体，该方法就可以定义为抽象方法。

抽象类不能创建对象
抽象类可以有构造方法
抽象类不一定有抽象方法，有抽象方法的类一定是抽象类
抽象类的子类要么重写抽象类中所有的抽象方法，要么子类也得是抽象类。

接口

接口就是一种规则。
抽象类表示一类事务，接口表示一种行为。

public interface 接口名{}

接口不能实例化
接口和类之间是实现关系

public class 类名 implements 接口名{}

接口的子类：要么重写接口中所有的抽象方法，要么是抽象类。

注意：

接口和类的实现关系可以是单实现，也可以是多实现。

实现类可以在继承一个类的同时实现多个接口。
public class 类名 extends 父类 implements 接口名1, 接口名2 {}

接口中成员的特点

成员变量：只能是常量，默认修饰符：public static final
构造方法：没有
成员方法：抽象方法或有方法体的方法，默认修饰符：public abstract

接口和类之间的关系

类和类的关系
继承关系，只能单继承，不能多继承，可以多层继承。
类和接口的关系
实现关系，可以单实现，也可以多实现，还可以再继承一个类的同时实现多个接口。
接口和接口的关系
继承关系，可以单继承，也可以多继承。

JDK8接口新增的方法

默认方法

JDK8以后：接口可以定义有方法体的方法，允许在接口中定义默认方法，需要用关键字default修饰
格式：public default 返回值类型方法名(参数列表) {}

默认方法不是抽象方法，不强制重写，如果被重写，重写的时候需要去掉default关键字。

public可以省略，default不能省略。

如果实现了多个接口，多个接口存在相同名字的默认方法，子类就必须对该方法进行重写。

静态方法

允许在接口中定义静态方法，需要用static修饰。
格式：public static 返回值类型方法名(参数列表) {}

静态方法只能通过接口名调用，不能通过实现类或对象名调用。

public可以省略，static不能省略。

接口的应用

接口代表规则，是行为的抽象，想要让哪个类拥有一个行为，就让这个类实现对应的接口。
接口多态：当一个方法的参数是接口时，可以传递接口所有实现类的对象。

适配器模式：解决接口与接口实现类之间的矛盾问题

场景：假设一个接口有多个抽象方法，想让某个继承这个接口的类只实现其中一个方法。

interface Inter {
    public abstract void fun1();
    public abstract void fun2();
    public abstract void fun3();
}
// 中间写一个适配器，空实现Inter接口的所有方法。
abstract class InterAdapter implements Inter { // 使用abstract是为了防止InterAdapter创建对象，因为没有意义

    @Override
    public void fun1() {

    }

    @Override
    public void fun2() {

    }

    @Override
    public void fun3() {

    }
}
// 如果只想要实现Inter接口的第三个抽象方法(如果还想要继承其他类，也可以让中间的适配器类去继承其他的类)
public class InterImpl extends InterAdapter {
    // 需要用到哪个方法，就重写哪个方法
    @Override
    public void fun3() {
        //...
    }
}

内部类

在一个类的里面，再定义一个类。

内部类表示的事物是外部类的一部分，单独出现没有任何意义。
内部类可以访问外部类的成员，包括私有。
外部类要访问内部类的成员，必须创建对象。

// 外部类
public class Car {
    private String carName;
    int carAge;
    String carColor;
    public void show() { // 外部类要访问内部类的成员，必须创建对象
        System.out.println(carName);
        // System.out.println(engineName); // 代码报错
    }
    // 内部类
    class Engine {
        String engineName;
        int engineAge;
        public void show() { // 内部类可以直接访问外部类的成员，包括私有。
            System.out.println(engineName + carName);
        }
    }
}

成员内部类

写在成员位置，属于外部类的成员。

class Outer {
    private String a = "Outer";
    class Inner {
        String a = "Inner";
        public void show() {
            System.out.println(a); // Inner
            System.out.println(this.a); // Inner
            System.out.println(Outer.this.a); // Outer【Outer.this：获取外部类对象的地址值】
        }
    }
    public Inner getInstance() {
        return new Inner();
    }
}
public class Demo04 {
    public static void main(String[] args) {
        // 获取成员内部类的对象
        // 方法1：直接创建（内部类被非私有修饰）
        Outer.Inner oi1 = new Outer().new Inner();
        // 方法2：通过get方法（内部类使用private修饰）
        Outer o = new Outer();
        Outer.Inner oi2 = o.getInstance();
    }
}

静态内部类

只能访问外部类中静态变量和静态方法，如果访问非静态的需要创建对象。

创建静态内部类对象的格式：外部类名.内部类名对象名 = new 外部类名.内部类名()
调用非静态方法的格式：先创建对象，用对象调用
调用静态方法的格式：外部类名.内部类名.方法名()

局部内部类

将内部类定义在方法里就叫局部内部类，类似于方法里的局部变量。
外界无法直接使用，需要在方法内部创建对象并使用。
可以直接访问外部类的成员，也可以访问方法里的局部变量。

匿名内部类（重点）

匿名内部类的本质就是隐藏了名字的内部类。

new 类名或接口名() {
	重写方法;
}

interface Swim {
    public abstract void swim();
}
abstract class Animal {
    public abstract void eat();
}
public class Demo05 {
    public static void main(String[] args) {
        Swim swim = new Swim() {
            @Override
            public void swim() {
                System.out.println("swim...");
            }
        };

        // 如果这个类只使用一次，可以考虑定义成匿名内部类
        method(new Animal() {
            @Override
            public void eat() {
                System.out.println("eat...");
            }
        });
    }

    public static void method(Animal a) {
        a.eat();
    }
}

使用场景，如果定义的类或接口只使用一次，可以使用匿名内部类简化代码。

javase-类和对象

类和对象

定义类

JavaBean类

测试类

封装

构造方法

对象内存图

虚拟机创建一个对象的过程

一个对象的内存图

两个对象的内存图

两个引用指向同一个对象

基本数据类型和引用数据类型

this的内存原理

static

修饰成员变量（静态变量）

修饰成员方法（静态方法）

工具类

继承

继承的特点

子类能继承父类的东西

构造方法

构造方法的访问特点

成员变量

成员方法

虚方法表

方法重写

this、super使用总结

多态

多态的优势

多态的弊端

包

使用其他类的规则

final

权限修饰符

代码块

抽象类

接口

接口中成员的特点

接口和类之间的关系

JDK8接口新增的方法

默认方法

静态方法

接口的应用

适配器模式：解决接口与接口实现类之间的矛盾问题

内部类

成员内部类

静态内部类

局部内部类

匿名内部类（重点）