java学习（七）java中抽象类及 接口

抽象类的特点：

A：抽象类和抽象方法必须用abstract关键字修饰。

B:抽象类中不一定有抽象方法，但是抽象方法的类必须定义为抽象类

c: 抽象类不能被实例化，因为它不是具体的。

     抽象类有构造方法，但不能被实例化？构造方法的作用是什么？

     用于子类访问父类数据的初始化。

D：抽象的子类。

        如果不想重写抽象类的方法，该子类是个抽象类。重写所有的抽象方法，这个时候子类是一个具体的类

抽象类Demo:

//abstract class Animal //抽象类的声明格式
abstract class Animal {
    //抽象方法
    //public abstract void eat(){} //空方法体,这个会报错。抽象方法不能有主体
    public abstract void eat();
    
    public Animal(){}
}

//子类是抽象类
abstract class Dog extends Animal {}

//子类是具体类，重写抽象方法
class Cat extends Animal {
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

class AbstractDemo {
    public static void main(String[] args) {
        //创建对象
        //Animal是抽象的; 无法实例化
        //Animal a = new Animal();
        //通过多态的方式
        Animal a = new Cat();
        a.eat();
    }
}

 抽象实例：

/*
    抽象类的成员特点：
        成员变量：既可以是变量，也可以是常量。
        构造方法：有。
                    用于子类访问父类数据的初始化。
        成员方法：既可以是抽象的，也可以是非抽象的。
        
    抽象类的成员方法特性：
        A:抽象方法 强制要求子类做的事情。
        B:非抽象方法 子类继承的事情，提高代码复用性。
*/
abstract class Animal {
    public int num = 10;
    public final int num2 = 20;

    public Animal() {}
    
    public Animal(String name,int age){}
    
    public abstract void show();
    
    public void method() {
        System.out.println("method");
    }
}

class Dog extends Animal {
    public void show() {
        System.out.println("show Dog");
    }
}

class AbstractDemo2 {
    public static void main(String[] args) {
        //创建对象
        Animal a = new Dog();
        a.num = 100;
        System.out.println(a.num);
        //a.num2 = 200;
        System.out.println(a.num2);
        System.out.println("--------------");
        a.show();
        a.method();
    }
}

/*
    猫狗案例
        具体事物：猫，狗
        共性：姓名，年龄，吃饭

    分析：从具体到抽象
        猫:
            成员变量：姓名，年龄
            构造方法：无参，带参
            成员方法：吃饭(猫吃鱼)
            
        狗:
            成员变量：姓名，年龄
            构造方法：无参，带参
            成员方法：吃饭(狗吃肉)
            
        因为有共性的内容，所以就提取了一个父类。动物。
        但是又由于吃饭的内容不一样，所以吃饭的方法是抽象的，
        而方法是抽象的类，类就必须定义为抽象类。
        
        抽象动物类：
            成员变量：姓名，年龄
            构造方法：无参，带参
            成员方法：吃饭();
    
    实现：从抽象到具体
        动物类:
            成员变量：姓名，年龄
            构造方法：无参，带参
            成员方法：吃饭();
            
        狗类：
            继承自动物类
            重写吃饭();
            
        猫类：
            继承自动物类
            重写吃饭();
*/
//定义抽象的动物类
abstract class Animal {
    //姓名
    private String name;
    //年龄
    private int age;
    
    public Animal() {}
    
    public Animal(String name,int age) {
        this.name = name;
        this.age = age;
    }
    
    public String getName() {
        return name;
    }
    
    public void setName(String name) {
        this.name = name;
    }
    
    public int getAge() {
        return age;
    }
    
    public void setAge(int age) {
        this.age = age;
    }
    
    //定义一个抽象方法
    public abstract void eat();
}

//定义具体的狗类
class Dog extends Animal {
    public Dog() {}
    
    public Dog(String name,int age) {
        super(name,age);
    }
    
    public void eat() {
        System.out.println("狗吃肉");
    }
}

//定义具体的猫类
class Cat extends Animal {
    public Cat() {}
    
    public Cat(String name,int age) {
        super(name,age);
    }
    
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

//测试类
class AbstractTest {
    public static void main(String[] args) {
        //测试狗类
        //具体类用法
        //方式1：
        Dog d = new Dog();
        d.setName("旺财");
        d.setAge(3);
        System.out.println(d.getName()+"---"+d.getAge());
        d.eat();
        //方式2：
        Dog d2 = new Dog("旺财",3);
        System.out.println(d2.getName()+"---"+d2.getAge());
        d2.eat();
        System.out.println("---------------------------");
        
        Animal a = new Dog();
        a.setName("旺财");
        a.setAge(3);
        System.out.println(a.getName()+"---"+a.getAge());
        a.eat();
        
        Animal a2 = new Dog("旺财",3);
        System.out.println(a2.getName()+"---"+a2.getAge());
        a2.eat();
        

    }
}

抽象类不能和那些关键字共存

/*
一个类如果没有抽象方法，可不可以定义为抽象类?如果可以，有什么意义?
    A:可以。
    B:不让创建对象。

abstract不能和哪些关键字共存?
    private    冲突
    final    冲突    
    static    无意义
*/
abstract class Fu {
    //public abstract void show();
    //非法的修饰符组合: abstract和private
    //private abstract void show();
    
    //非法的修饰符组合
    //final abstract void show();    
    
    //非法的修饰符组合
    static abstract void show();
    
    public static void method() {
        System.out.println("method");
    }
}

class Zi extends Fu {
    public void show() {}
}

class AbstractDemo3 {
    public static void main(String[] args) {
        Fu.method();
    }
}

接口的特点：

A：接口用关键字interface表示,interface 接口名{}

B：类实现接口用implements 表示

      class  类名  implements 接口名{}

C：接口不能实例化

     接口实例化必须按照多态的方式来实现实例化的

D：接口的子类：

      可以是抽象类，但意义不大

      可以是具体类，要重写接口中所有抽象方法

/*
    接口的特点：
        A:接口用关键字interface表示    
            interface 接口名 {}
        B:类实现接口用implements表示
            class 类名 implements 接口名 {}
        C:接口不能实例化
            那么，接口如何实例化呢?
            按照多态的方式来实例化。
        D:接口的子类
            a:可以是抽象类。但是意义不大。
            b:可以是具体类。要重写接口中的所有抽象方法。(推荐方案)
    
    由此可见：
        A:具体类多态(几乎没有)
        B:抽象类多态(常用)
        C:接口多态(最常用)
*/
//定义动物培训接口
interface AnimalTrain {
    public abstract void jump();
}

//抽象类实现接口
abstract class Dog implements AnimalTrain {
}

//具体类实现接口
class Cat implements AnimalTrain {
    public void jump() {
        System.out.println("猫可以跳高了");
    }
}

class InterfaceDemo {
    public static void main(String[] args) {
        //AnimalTrain是抽象的; 无法实例化
        //AnimalTrain at = new AnimalTrain();
        //at.jump();
        
        AnimalTrain at = new Cat();
        at.jump();
    }
}

接口成员特点：

   成员变量：

        只能是常量，默认饰符  public static final

   构造方法：

       没有，因为接口主要是扩展功能的，而没有具体存在

   成员方法：

       只能是抽象方法，默认修饰符  public abstract

/*
    接口成员特点
        成员变量；只能是常量，并且是静态的。
                默认修饰符：public static final
                建议：自己手动给出。
        构造方法：接口没有构造方法。
        成员方法：只能是抽象方法。
                默认修饰符：public abstract
                建议：自己手动给出。
        
    所有的类都默认继承自一个类：Object。
    类 Object 是类层次结构的根类。每个类都使用 Object 作为超类。
*/
interface Inter {
    public int num = 10;
    public final int num2 = 20;
    public static final int num3 = 30;
    
    //错误: 需要<标识符>
    //public Inter() {}
    
    //接口方法不能带有主体
    //public void show() {}

    //abstract void show(); //默认public
    public void show(); //默认abstract
}

//接口名+Impl这种格式是接口的实现类格式
/*
class InterImpl implements Inter {
    public InterImpl() {
        super();
    }
}
*/

class InterImpl extends Object implements Inter {
    public InterImpl() {
        super();
    }
    
    public void show() {}
}

//测试类
class InterfaceDemo2 {
    public static void main(String[] args) {
        //创建对象
        Inter i = new InterImpl();
        System.out.println(i.num);
        System.out.println(i.num2);
        //i.num = 100;
        //i.num2 = 200;
        //System.out.println(i.num); //无法为最终变量num分配值
        //System.out.println(i.num2);//无法为最终变量num2分配值
        System.out.println(Inter.num);
        System.out.println(Inter.num2);
        System.out.println("--------------");
    }
}