面向对象1

成员方法存储的位置

对象存在“堆内存”中。如果创建多个对象，那么”堆内存“就会容易存满。因为文件在“方法区”中，文件中有方法，直接使用“方法区”中的方法就可以，节约内存空间。

static关键字

• static修饰的成员变量称为类变量；
• static修饰的成员方法称为类方法，也叫静态方法；
• static修饰的代码块{}叫静态代码块。

静态方法：

• 用类直接调用静态方法
• 不能使用this关键字
• 不能访问成员变量/方法，反之可以
• 可以访问类变量/方法。
• 静态方法随着类的加载而加载，且只加载一次，存放在静态区，可以被所有对象共享。

静态代码块：优先于 main()方法和构造方法执行，用于给类变量初始化赋值。

public class Student {
    public static int number;

    static {
        number = 2;
    }
}

封装

封装1：this关键字

1. 使用private修饰成员变量
2. 使用getXX，setXX访问成员变量

封装2：构造方法

• 使用构造方法，在创建对象时，给成员变量赋值/或者什么都不做

JavaBean是JAVA类的一种编写规范，规范要求类是具体的和公共的，并且具有无参构造方法。

public class Student {
    private String name;

    // 无参构造
    public Student() {
    }

    // 有参构造
    public Student(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

继承

• JAVA 只能单继承，不能多继承；
• 所有的类默认继承Object类；
• 调用父类成员需要使用super关键字，和this区分；
• 无权访问父类中private权限的成员，可以使用getXX/setXX；
• 定义构造方法时，要先使用super();执行父类构造方法。

class People {
    String name = "张三";

    public void speak() {
        System.out.println("Hello");
    }
}

class Teacher extends People {
    String name = "老师";

    public void speak() {
        System.out.println(this.name);
        super.speak();
        System.out.println("Hello World");
    }
}   

抽象类

方法或类都只是为了声明，没有主体，此时可以定义为 抽象方法/抽象类。

• 包含抽象方法的类，必须是抽象类。
• 继承抽象类，没有重写抽象方法的类，必须是抽象类。
• 抽象类不能创建对象
• 抽象类可以有构造方法

abstract class People {
    abstract public void speak();
}

class Teacher extends People {
    public void speak() {
        System.out.println("Hello World");
    }
}

接口

接口中可以包含：

• 抽象方法：必须在实现类中重写@Override
• 默认方法：可以重写，也可以省略；JAVA8中添加的，可以解决接口升级问题。
• 静态方法：只能使用接口名调用；
• 私有方法：只有默认方法可以调用，解决默认方法代码重用问题；
• 私有静态方法：默认方法和静态方法可以调用，解决静态方法代码重用问题；
• 常量：public static final int a = 1;

注意：

• 接口没有静态代码块
• 接口没有构造方法
• 接口可以继承接口，可以被多继承。

interface MyInterface {
    public static final int a = 12;
    public abstract void method1();
    public default void method2() {
        // pass
    }
    public static void method3() {
        // pass
    }
    private void method4() {
        // pass
    }
}

class MyTest implements MyInterface {
    @Override
    public void method1() {
        // pass
    }
}

多态

多态形式：

• 父类引用指向子类对象：父类 test = new 子类()
• 接口名称指向实现对象：接口 test = new 实现()

多态好处：

• 在实际应用中，父类常作为形参，传递子类对象；这样就可以只定义一个传递父类的函数，避免代码复用。

多态缺点：（通过向下转型解决）

• 无法使用子类的成员变量。
• 无法使用子类特有的成员方法。

多态转型：

• 向上转型：父类引用指向子类对象：Animal animal = new Cat();
• 向下转型：Cat cat = (Cat) animal;

转型出错：

1. 当父类引用调用子类特有的方法时会出错（需要向下转型）
2. 当向下转型，转到别的子类时会出错（猫->动物->狗）

避免转型出错：instanceof

• 使用语句判断：if (animal instanceof Cat)

final关键字

final：不可改变，用于修饰类、方法、变量。

权限修饰符

同一个类 同一个包 不同包的子类 不同包的非子类
public 可访问 可访问 可访问 可访问
protected 可访问 可访问 可访问
package 可访问 可访问
private 可访问

其中，package也叫default，是默认的，不用写。

内部类

成员内部类：定义在类的内部

• 内部类可以访问外部类成员，外部类需要创建内部类对象才能访问内部类。
• 内部类会被编译成.class文件，前面冠以外部类名Person$Hand.class

匿名内部类

匿名内部类：没有定义，一次使用。比如传递参数时直接new一个对象。