抽象与继承：Java中的抽象类与接口详解-CSDN博客

修饰符:abstract 抽象
1.修饰类:
语法格式:访问修饰符 abstract class 类名{}
抽象类中可以有抽象方法,也可以有普通方法,也可以有构造方法
不能被实例化,因为抽象类中可能存在抽象方法,需要重写抽象方法,才可以被实例化
抽象类的子类,要么重写抽象方法,要么把子类改为抽象类
2.修饰方法
语法格式:访问修饰符 abstract 方法返回值方法名();没有方法体和{}
什么时候使用:当需要子类强制重写的时候,就把该方法写成抽象的方法
例如:对美女的定义也是抽象的(清纯,成熟,日系,港风)
每种类型的美女打扮的方法也不一样

public class AbstractDemo01 {
    public static void main(String[] args) {
        //不可以直接创建抽象类对象
        //Beauty beauty=new Beauty();
        //参考多态
        Beauty beauty=new PureBeauty();//父类直接引用直接指向子类的对象(多态)

        beauty.dressing();
    }
}
abstract class  Beauty{
    //打扮的方法
//    public void dressing(){
//        System.out.println("打扮");
//    }
    //重写,所以当前打扮方法不能有方法体;
    //所以需要把当前的打扮方法做成抽象的方法
    public abstract void dressing();//抽象方法

    public void man(){
        //普通方法
    }
    public Beauty(){

    }
}
//清纯
class PureBeauty extends Beauty{
    /*
    重写
    2. 当前类继承抽象后,那么该类必须是抽象类
     */
    @Override
    public void dressing(){
        System.out.println("打扮清纯");
    }

}
//成熟
abstract class MatureBeauty extends Beauty{
//    //重写
//    @Override
//    public void dressing() {
//
//    }
    /*
    2. 当前继承类自抽象类后,还可以把子类写成抽象的
     */
}
class man extends MatureBeauty{
    @Override
    public void dressing() {

    }
}

内部类:
当一个事务的内部,还有一部分需要一个完整的结构进行描述(使用属性和方法描述不完整)
那么这个整个结构最好使用内部类,这个内部结构有为外部事物提供服务

内部类的使用:
在一个类中定义一个类
例如:
class A{
class B{
}
}

public class Demo01 {
    public static void main(String[] args) {
        //需要通过外部类对象创建内部类对象
         Outer.Inner a= new Outer().new Inner();
                a.show();
         //
        Outer outer=new Outer();
        outer.method();

    }
}
class Outer{
    private int num=10;
    class Inner{
        public void show(){
            //内部类,可以访问外部类所有的资源,包括私有的!
            System.out.println(num);
        }
    }
        public void method(){
        //外部类要访问内部类的成员,必须创建内部类对象
            Inner i=new Inner();
            i.show();
        }


}

内部类的分类:
成员内部类和局部内部类
成员变量:类中定义的
局部变量:方法中定义

成员内部类:
在类中定义的类,类中可以定义属性,方法,构造器,可以被final static abstract修饰

public class Demo02 {
    public static void main(String[] args) {
        Person.Cat c=new Person().new Cat();
        c.display("花花");
    }
}
class Person{
    String name="one";
    //成员内部类
    class Cat{
        int age;
        String name="two";
        public void eat(){
            System.out.println("猫在吃小鱼干");
        }
        //有参构造
        public Cat(String name,int age ){
            this.age=age;
            this.name=name;
        }
        public void  display(String name){
            System.out.println("方法参数"+name);//参数 就近原则
            System.out.println("内部类"+this.name);//内部类
            System.out.println("外部类"+Person.this.name);//外部类
        }
        //无参构造
        public Cat(){

        }
    }
}

接口:接口关键字 interface
格式:interface 接口名{}
接口里面可以写: 静态方法抽象方法

接口的特点:
1.不可以被实例化,
2.实现类的解决方案:

当前实现接口后,可以重写接口中的所有的抽象方法(如果实现类是普通类型则实现后,需要重写接口中的抽象方法)
将实现类变成抽象类,不重写接口中的抽象方法也可以(如果是抽象类,则可不重写抽象方法)

继承:类与类之间的关系,使用extends

类中可有的
普通类: 静态方法、构造方法、非静态方法、静态变量、非静态变量
抽象类：静态方法、构造方法、非静态方法、静态变量、非静态变量、抽象方法

类与类之间单继承
类与接口之间是多继承
接口与接口之间是多继承

public class InterfaceDemo {
    public static void main(String[] args) {

    }
}
//接口Aoo
interface Coo{
    //定义并初始化 -->静态常量
    int a=10;//==static final int a=10;
    static final int b=10;
    /*
     在接口中定义的都是静态常量,必须定义的时候初始化
     */

    //不可以放构造方法
//    public Aoo(){
//
//    }
    //不可以放普通方法
//    public  void add(){
//
//    }
    //静态方法
    public static void test(){
        //jdk1.8之后接口中可以定义静态方法
    }
    //抽象方法
    public abstract void demo();

}
abstract class Aoo implements Coo{
    //将实现类变成抽象类
}
//Doo是类,Coo是接口,两者之间可以有实现关系,用的是implements
class Doo implements Coo {
    //当Doo实现Coo类型之后,需要重写Coo中的所有抽象方法
    @Override
    public void demo() {

    }
}
//类和类之间是单继承的!!!!!!!!!!!!!
//Hoo接口  Coo也是接口 使用的是继承;接口之间的继承是多继承的!!!!!!!!!
interface Hoo extends Coo {

}
interface Zoo{

}
interface Roo{

}
class Soo implements Roo,Zoo{
        //Soo是类,Roo和Zoo是接口,类是可以实现多接口的!!!!!!!!!
}

java第16天