面向对象

类的组成

成员变量

局部变量和成员变量区别

成员变量的默认值

内存分析

• 代码1

public class Person {
    int id;
    int age;

    public static void main(String[] args) {
        Person p1 = new Person();
        System.out.println(p1.age); // 0
    }
}

• 代码2

public class Person {
    int id;
    int age;
    String school;

    public Person(int a, int b, String c) {
        id = a;
        age = b;
        school = c;
    }

    public static void main(String[] args) {
        Person p = new Person(1, 20, "数加");
    }
}

步骤

• main方法作为程序的入口：在栈中开辟main方法栈帧
• 第一次遇到Person：在方法区中加载Person.class字节码信息
• new关键字出现：参照字节码信息在堆中创建对象，并给对象的属性做初始化操作（赋予默认值0、0、null）
• 调用有参构造方法Person(1, 20, "数加")进行形参的传递：在栈中开辟构造方法Person()栈帧，局部变量a、b、c先进后出，a和b直接赋值1和20，第一次遇到字符串"数加"时，会将其放入方法区中的字符串常量池，再将地址值传给c
• 有参构造方法内部的赋值操作：将a、b、c的值分别赋给id、age、school，其中c是将地址值赋给了school，school通过该地址值可以访问字符串常量池中对应的字符串，此时，有参构造方法被调用执行完毕，对应的栈帧被回收
• Person p = new Person(1, 20, "数加")：将堆中创建对象的地址值赋给p

代码块

修饰符

权限修饰符

一般来说，属性用private修饰，方法用public修饰。

static修饰符

static内存分析

final修饰符

abstract修饰符

static、final、abstract的区别

封装

继承

多态

JAVA是一种强类型语言，在定义形参时需要声明每一个参数的数据类型，如果形参过多，但这些形参类型都有一个共同的父类，那么在形参列表中可以只声明一个父类类型的变量，而传递的实际参数既可以是父类类型的对象，也可以是不同子类类型的对象。当传递子类对象时，方法内部调用的方法即为该子类对象对父类重写后的方法，这样一来，后续添加新的子类或修改子类的方法时，就无需再修改该方法内部的代码，只需将子类对象作为实参进行传递即可！

实现方式：类、抽象类、接口

形参及返回值问题

形参

返回值

内部类

成员内部类

局部内部类

匿名内部类

格式

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

切记：匿名内部类不是一个类而是一个对象，是一个子类或实现类对父类或接口进行重写后没有进行命名，只保留了方法体，再加上父类名或接口名来进行该匿名类对象的创建，是一种代码的简化写法。

普通写法

以接口为例：单独写一个实现类---主程序中创建一个实现类对象---通过该对象调用方法

interface Swim {
    public abstract void swimming();
}

// 1. 定义接口的实现类
class Student implements Swim {
    // 2. 重写抽象方法
    @Override
    public void swimming() {
        System.out.println("狗刨式...");
    }
}

public class Test {
    public static void main(String[] args) {
        // 3. 创建实现类对象
        Student s = new Student();
        // 4. 调用方法
        s.swimming();
    }
}

匿名内部类写法

以接口为例：直接写成匿名内部类形式（相当于创建了一个实现类对象）---直接通过该对象调用方法/使用接口的引用来接收该对象（多态）再进行方法的调用

interface Swim {
    public abstract void swimming();
}

public class Demo07 {
    public static void main(String[] args) {
        // 使用匿名内部类
		new Swim() {
			@Override
			public void swimming() {
				System.out.println("自由泳...");
			}
		}.swimming();

        // 接口 变量 = new 实现类(); // 多态,走子类的重写方法
        Swim s2 = new Swim() {
            @Override
            public void swimming() {
                System.out.println("蛙泳...");
            }
        };

        s2.swimming();
        s2.swimming();
    }
}

应用场景

匿名内部类本身就是一个对象，当方法的形参类型是抽象类或接口时，可以直接作为参数传入该方法。

interface Swim {
    public abstract void swimming();
}

public class Demo {
    public static void main(String[] args) {
        
        // 匿名内部类作为方法参数传递
        Swim s3 = new Swim() {
            @Override
            public void swimming() {
                System.out.println("蝶泳...");
            }
        };
        // 传入匿名内部类
        goSwimming(s3);

        // 完美方案: 一步到位
        goSwimming(new Swim() {
            public void swimming() {
                System.out.println("大学生, 蛙泳...");
            }
        });

        goSwimming(new Swim() {
            public void swimming() {
                System.out.println("小学生, 自由泳...");
            }
        });
    }

    // 定义一个方法,模拟请一些人去游泳
    public static void goSwimming(Swim s) {
        s.swimming();
    }
}