来喽！Java抽象类，接口，内部类

Java学习中，整理一些知识点，希望大神多多指教！

一、抽象类

概述： 用来描述抽象类
1、被abstract抽象类修饰
2、有抽象方法的类一定是抽象类（有抽象方法的类，必须被定义为抽象类）；但抽象类中不一定有抽象方法
3、可以有构造方法，但无法去创建对象，它的构造方法是供子类初始化父类数据用的
4、抽象类可以被继承
a、子类必须重写抽象类中所有的抽象方法
b、抽象类可以继承抽象类，并且不需要实现父类中的抽象方法

public class AbstractDemo {
    public static void main(String[] args) {
        Pets pets = new Dog();//Pets 构造方法
        pets.method();//Abstract Pets Method()
        pets.eat();
    }
}

abstract class Cat extends Pets{

}
abstract class Pets{
    //抽象方法
    public abstract void eat();

    public abstract void voice();

    //非抽象方法
    public void method() {
        System.out.println("Abstract Pets Method()");
    }
    public Pets(){
        System.out.println("Pets 构造方法");
    }

}

class Dog extends Pets{
    @Override
    public void eat() {
        //alt+insert
        System.out.println("eat");
    }

    @Override
    public void voice() {
        System.out.println("voice");
    }
}

二、接口

概述： 一个类所具有的方法的特征集合，是一种逻辑上的抽象
1、接口需要使用关键字interface
interface 接口名{ }
2、扩充功能
使用关键字implements
class 类名 implements
3、实现接口的标准类
4、接口中只能有抽象的方法，并且每个方法默认都是被public abstract修饰
5、接口不能被实例化，但是可以通过多态的方式实例化
6、一个类可以实现多个接口

public class InterFaceDemo {
    public static void main(String[] args) {
        //通过多态实例化
        ComputerExtend ce = new Computer();
        ce.printMethod();//我可以打印了
        ce.design();//我可以设计了
        ComputerPlay cp = new Computer();
        cp.gamePad();//我可以打游戏了
    }
}
//接口
interface ComputerPlay{
    public abstract void gamePad();//游戏手柄
}
//接口
interface ComputerExtend{
    public abstract void printMethod();//打印功能
    public abstract void design();//设计功能
}


class Computer implements ComputerExtend,ComputerPlay{
    @Override
    public void printMethod() {
        System.out.println("我可以打印了");
    }

    @Override
    public void design() {
        System.out.println("我可以设计了");
    }

    @Override
    public void gamePad() {
        System.out.println("我可以打游戏了");
    }
}

三、内部类

概述： 把类定义在其他类的内部，这个类被称为内部类
访问特点：
1、内部类可以直接访问外部类里面的方法，包括私有的
2、外部类要访问内部类的成员,需要先创建内部类的对象

public class InnerDemo {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.function2();//30 20
    }
}
//外部类
class Outer{
    private int num2 = 20;
    //外部类成员方法
    public void function(){
    //外部类访问内部类
        Inner inner = new Inner();
        inner.showInfo();
    }
    public void function2(){
        function();
    }
    //内部类
    class Inner{
        //成员变量
        int num = 30;
        //成员方法
        private void showInfo(){
            System.out.println(num);
            System.out.println(num2);
        }
    }
}

内部类的分类：
1、成员内部类：声明在成员位置的类
2、局部内部类
创建成员内部类对象：
静态：外部类.内部类 对象名 = new 外部类.内部类（）；
非静态：外部类名.内部类名 对象名 = new 外部类名().new 内部类名();
局部内部类:
1、可以访问外部类的成员，包括私有的
2、访问局部内部类需要在在成员方法作用域内创建对象

public class InnerDemo2 {
    public static void main(String[] args) {
        Outer2.Inner2 inner2 = new Outer2().new Inner2();
        inner2.showInfo();//30
        System.out.println(inner2.num2);//20
        
        Outer2 outer2 = new Outer2();
        outer2.method();//30
    }
}
class Outer2{
    //成员变量
    public int num = 30;
    //成员内部类
    class Inner2{
        public int num2 = 20;
        public void showInfo(){
            System.out.println(num);
        }
    }
    //成员方法
    public void method(){
    	//局部变量
    	int num3 = 40;
        //局部内部类
        class Inner3{
            public void showInfo2(){
                System.out.println(num);
            }
        }
        //在成员方法作用域内创建对象
        Inner3 inner3 = new Inner3();
        inner3.showInfo2();
    }
}

注： 因为局部变量类 与 局部变量生命周期冲突的原因，所以需要借助final关键字来解决这个冲突，即局部变量默认被final修饰
匿名内部类：
概述：内部类的简化写法
前提：存在一个类(抽象类) 或 接口
格式：new 类名 或 接口名(){重写方法};
本质：是一个继承子类 或 实现了接口的子类（实现类）匿名对象

public class InnerDemo5 {
    public static void main(String[] args) {
        Outer6 outer6 = new Outer6();
        outer6.method();//1 2
    }
}
interface Inter{
    public abstract void showInfo();
    public abstract void showInfo2();
}
class Outer6{
    //匿名内部类
    public void method(){
        //用多态实现
        Inter inter = new Inter() {
            @Override
            public void showInfo() {
                System.out.println("1");
            }

            @Override
            public void showInfo2() {
                System.out.println("2");
            }
        };
        inter.showInfo();
        inter.showInfo2();
    }
}