小白学习Java第十课抽象类，接口，内部类

抽象方法和抽象类：
抽象方法，是使用abstract修饰的方法，没有方法体，只有声明。定义的是一种模板，告诉子类给抽象方法提供具体的实现。
抽象类，是包含抽象方法的类，也可以有普通方法。但是有抽象方法的类只能定义成抽象类，并且抽象类不能用new来实例化抽象类。抽象类只能用来被继承且不可以多继承，抽象方法必须被子类实现。

//抽象类为子类提供规范统一的模板
abstract public class Testc {
    //1、没有实现2、子类实现
    abstract public void shout();
    public void sleep(){
        System.out.println("睡了");
    }
}
class  cat extends Testc{
    public void shout(){
        System.out.println("喵~~");
    }
}

接口：比抽象类更抽象的抽象类，接口中所有的方法都是抽象方法。接口和实现类不是父子关系，而是实现规则关系。
接口的声明格式：【访问修饰符】 interface 接口名 【extends 父接口1，父接口2】{ 常量方法； 方法定义；}接口可以实现多继承。
子类通过implements来实现接口中的规范，但是接口不能创建实例，但是可用于声明引用变量类型，一个类如果要实现一个接口必须实现这个接口中的所有方法，并且这些方法只能是public。

//接口  只能定义常量
/*public interface Testm {
    (public static final )int MAX=100;
    (public abstract )void test();
}*/
public class  Testm{
    public static void main(String[] args) {
        fly f=new Animal();
        f.fly();
        run p=new People();
        p.run();
    }
}
interface fly{
    int FLY=100;
    void fly();
}
interface run{
    void run();
}
class Animal implements fly,run{

    @Override
    public void fly() {
        System.out.println("I can fly");
    }

    @Override
    public void run() {
        System.out.println("I can run");
    }
}
class People implements run{

    @Override
    public void run() {
        System.out.println("我会跑");
    }
}

接口的多继承：

public  class Testm {

}
interface aa{
    void as();
}
interface bb{
    void bs();
}
interface cc extends aa,bb {//j接口的多继承，接口cc继承接口aa和bb
    void cs();
}
class test implements cc{

    @Override
    public void as() {

    }

    @Override
    public void bs() {

    }

    @Override
    public void cs() {

    }
}

内部类：
Java中内部类主要分为成员内部类（包括非静态内部类，静态内部类），匿名内部类，局部内部类。
成员内部类中的非静态内部类，可以直接访问外部类，但是外部类不可以访问内部类。不同内部类不可以加static修饰，如果要加的话用静态内部类。
相关代码：

public class Testn {
    public static void main(String[] args) {
        //创建内部类对象
        Outer.Inner ii=new Outer().new Inner();
        ii.show();
    }
}
class Outer{
    private int id=12;
    public void test1(){}
    class Inner{
        int id=123;
        public void show(){
            System.out.println(Outer.this.id);//外部类
            System.out.println(this.id);//内部类
        }
    }
}

匿名内部类，匿名内部类没有访问修饰符，没有构造方法，多用于只用一次的情况，语法如下：

new 父类构造方法（实参类表）\实现接口（）{
//匿名内部类类体！}

相关代码如下：

public class Testn {
    public static void test(a1 a){
        System.out.println("sssssssss");
        a.a1();
    }

    public static void main(String[] args) {
        Testn.test(new a1() {
            @Override
            public void a1() {
                System.out.println("aaaaaaa");
            }
        });
    }
}
interface a1{
    void a1();
}

局部内部类;
方法中的内部类，作用于只限于本方法，一般用于解决复杂问题创建一个类辅助我们解决方案。

public class Testn {
    public void show(){
        //作用于本方法内
        class Inner{
            public void ff(){
                System.out.println("你好");
            }
            
        }
        new Inner().ff();
    }

    public static void main(String[] args) {
        new Testn().show();
    }
}