（Java入门）抽象类，接口，内部类

一.抽象类

抽象关键字：abstract----抽象方法--所在的类--抽象类

抽象方法--子类必须强制重写，否则代码直接报错。

注意：抽象类不能创建对象（不能实例化）

抽象类有构造方法，当创建子类对象时，给属性赋值使用。

  

其父类不一定是抽象的

吃--定义为抽象方法--所在的类--抽象类

当子类继承抽象类的时候，需要重写空参和带全部参数的构造。并且重写抽象方法。

package demo5;

public 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 void drink(){
        System.out.println("动物在喝水");
    }

    public abstract void eat();
}

package demo5;

public class Dog extends Animal{

    public Dog() {
    }

    public Dog(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("狗在吃狗粮");
    }
}

package demo5;

public class Frog extends Animal{
    public Frog() {
    }

    public Frog(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("青蛙在吃虫子");
    }
}

package demo5;

public class Test {
    public static void main(String[] args) {
        Dog d1=new Dog("taidi",5);
        System.out.println(d1.getName()+","+d1.getAge());
        d1.drink();
        d1.eat();
    }
}

抽象类和抽象方法的出现，使子类变得统一

二.接口

按照接口里面定义的书写规则写代码（实现代码的统一）：接口---------理解为规则

光写在子类里面，就有可能不统一。---写一个抽象类将其统一起来。

接口--理解为一种规则------当需要给多个类同时定义规则的时候，就需要用到接口。

接口--对行为的一种抽象。

 抽象类--更多用在父类当中     接口--侧重于行为

一个类可以实现多个接口：

 

当继承抽象的父类和接口时，需要进行重写

package demo6;

public 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();
}

package demo6;

public class Dog extends Animal implements Swim{

    public Dog() {
    }

    public Dog(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }

    @Override
    public void swim() {
        System.out.println("狗刨");
    }
}

package demo6;

import demo5.Animal;


public class Frog extends Animal implements Swim{
    public Frog() {
    }

    public Frog(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("青蛙吃虫子");
    }

    @Override
    public void swim() {
        System.out.println("青蛙会蛙泳");
    }
}

package demo6;

public class Rabbit extends Animal{
    public Rabbit() {
    }

    public Rabbit(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("兔子吃胡萝卜");
    }


}

package demo6;

public interface Swim {
    public abstract void swim();
}

package demo6;

public class Test {
    public static void main(String[] args) {
        Frog qw1=new Frog("xiaoqin",2);
        qw1.eat();
        qw1.swim();
        System.out.println(qw1.getAge()+","+qw1.getName());
        Dog d1=new Dog("td",3);
        d1.eat();
        d1.swim();
        System.out.println(d1.getName()+","+d1.getAge());
        Rabbit r1=new Rabbit("小白",1);
        r1.eat();
        System.out.println(r1.getName()+","+r1.getAge());

    }
}

 三.接口的细节

1.接口是一种规则，不能被改变  接口中的成员变量都是常量，会用final去修饰

2.没有构造方法，不能创建对象，也不需要给子类的成员变量去赋值

//test测试类在运行时的id

继承一个接口，要重写所有的方法。

四.综合案例

设置继承：子类是父类的一种+一个父类中所有的子类需要是同一种事物。