【Java基础】学习笔记3 - 抽象类与内部类

final

final 经常被称为终结修饰符，被他修饰后一般具有如下功能

1. 阻止类被继承
2. 阻止父类的方法被覆写
3. 阻止属性被修改
4. 阻止局部变量被修改

被 final 修饰的属性只能在两个位置初始化：定义时；静态代码块里面；
不要试图在构造函数里面为 final 变量赋值！！！

你没有必要在为一个 final 类下的方法设置 final 修饰

final 和 static 搭配工作效率更高哦！

抽象类

抽象类必背规则

1. 抽象类不可实例化
2. 抽象类可以没有抽象方法
3. 类内只要存在一个抽象方法，他就必须声明为抽象类
4. abstract 仅能修饰方法和类
5. 抽象类内可以有任何普通类所拥有的成员
6. 一个类继承了抽象类，就必须实现其中所有的抽象方法，除非这个类也是抽象类
7. 抽象方法不能有函数体
8. 抽象方法不可用 private，final，static 等阻止重写的修饰符来修饰

简易的根据上述知识构筑的抽象类和抽象方法实验代码

package chapter2;

public class AbstractDemo {
    public static void main(String[] args) {
        AbstractEntity entity = new AbstractEntity();
        entity.getName();
        entity.sayHi();
    }
}

abstract class Abstract1 {
    public abstract void getName();

    public void sayHi() {
        System.out.println("hw");
    }
}

class AbstractEntity extends Abstract1{
    @Override
    public void getName() {
        System.out.println("no name");
    }
}

接口

接口内的静态方法、默认方法可以自带函数体，其余的函数都不可以有函数体

interface USBInterface {
    public void getType();

    // 默认方法
    default public void defTest(){
        System.out.println("default test");
    }

    // 静态方法
    public static void staticTest() {
        System.out.println("static test");
    }
}

接口使用细节

1. 接口不可以实例化
2. 接口中的抽象方法无需加 abstract 修饰符
3. 接口中所有方法均为 public
4. 普通类实现接口，必须重写方法；抽象类实现接口，可以一个方法都不重写
5. 一个类可实现多个接口
6. 接口属性只能是 final 的
7. 访问接口属性，使用格式：接口名.属性名
8. 接口可以额外继承多个其他接口 interface B extends A,C{}

接口也可以实现多态，下面展示了数组多态

package chapter2;

public class InterfaceDemo {
    public static void main(String[] args) {
        Device[] devices = new Device[2];
        devices[0] = new Phone();
        devices[1] = new Computer();

        for (Device device : devices) {
            if (device instanceof Phone) ((Phone) device).call();
            else device.work();
        }
    }
}

interface Device {
    void work();
}

class Phone implements Device {
    @Override
    public void work() {
        System.out.println("phone work");
    }

    public void call() {
        System.out.println("打电话了");
    }
}

class Computer implements Device {
    @Override
    public void work() {
        System.out.println("computer work");
    }
}

接口多态传递现象

比如下方，A2 继承了接口 A1，那么我们的类实现了 A2 接口的同时也顺便实现了 A1 接口，呈现传递关系

package chapter2;

public class InterfacePolyLinkDemo {
    public static void main(String[] args) {
        A1 aa1 = new A();
        A2 aa2 = new A();
    }
}

interface A1 {
}

interface A2 extends A1 {
}

class A implements A2 {
}

内部类

局部内部类

定义于方法中，而且有类名

可访问外部类所有成员，包括私有
不可添加访问修饰符，但可以 final 修饰
作用域仅仅是方法内部

如果内部类有和外部类同名的属性或者方法，可以使用以下格式：外部类名.this.外部类属性或者方法名

package chapter3;

public class LocalInnerClass {
    public static void main(String[] args) {
        new LocalClass().getNum();
    }
}

class LocalClass {
    private int outNum = 1;

    public void getNum() {

        // 定义局部内部类 InnerClass
        class InnerClass {
            private int outNum = 2;

            public void say() {
                // 输出局部内部类的 outNum，即 2
                System.out.println(outNum);
                // 输出外部类的 outNum，即 1
                System.out.println(LocalClass.this.outNum);
            }
        }
        // 创建 InnerClass 的实例并调用 say() 方法
        new InnerClass().say();
    }
}

匿名内部类

定义于方法内，但是是匿名的

我们需要提供一个接口，来让匿名内部类有一个模板来参照

package chapter3;

public class AnonymousInnerClass {
    public static void main(String[] args) {
        new AnonymousClass().getWhatSay();
    }
}

interface A {
    void say();
}

class AnonymousClass {
    public void getWhatSay() {
        // 匿名内部类
        new A() {
            @Override
            public void say() {
                System.out.println("fuck");
            }
        }.say();
    }
}

匿名内部类的一个重要方法是把他当做一个实参来传递，从而简化代码操作

package chapter3;

public class AnonymousInnerClass {
    public static void main(String[] args) {
        // 调用方法，直接传入一个匿名类实现
        sayHello(new A() {
            @Override
            public void say() {
                System.out.println("hello world");
            }
        });
    }

    // 接收一个接口作为形参
    public static void sayHello(A a){
        // 调用接口方法
        a.say();
    }
}

interface A {
    void say();
}

成员内部类

直接作为外部类的一个成员出现，不被 static 修饰

他可以添加任何访问修饰符

内部类可以访问外部类所有成员，反过来也是一样的

package chapter3;

public class MemberInnerClass {
    public static void main(String[] args) {
        new MemberClass().sayHello();
    }
}

class MemberClass {
    private int num = 100;

    public void sayHello() {
        System.out.println("fuck");
        InnerClass innerClass = new InnerClass();
        System.out.println(innerClass.getNum() + innerClass.res);
    }

    class InnerClass {
        private int res = 1000;

        public int getNum() {
            return MemberClass.this.num;
        }
    }
}

静态内部类

直接作为外部类的一个成员出现， static 修饰

跟所有被 static 修饰的成员一样，该内部类只能访问外部类的静态成员