Java基础-第5天

1.抽象类

抽象类中有抽象方法，没有方法体的方法应该写为抽象方法，形如：

public abstract class Animal(){
	public abstract void eat(){
	}
}

抽象类的特点

抽象类中不一定有抽象方法，但是含有抽象方法的类一定是抽象类。抽象类参照多态的方式，通过子类对象实例化。
抽象类的子类要么重写抽象类中的所有抽象方法，要么它也是一个抽象类。

抽象类成员的特点

Animal类
public abstract class Animal {
    private int age = 20;
    private final String city = "北京";
    public  Animal(){

    }
    public Animal(int age){
        this.age = age;
    }
    public void show(){
        age = 40;
        System.out.println(age);
        System.out.println(city);
    }
    public abstract void eat();
}
Cat类
public class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("猫");
    }
}
AnimalDemo
public class AnimalDemo {
    public static void main(String[] args) {
        Animal a = new Cat();
        a.eat();
        a.show();

    }
}
输出结果为：
猫
40
北京

说明以下特点：

对于成员变量来说，抽象类中既可以是变量也可以是常量。
对于构造方法来说，它可以有构造方法，但是不能直接被实例化，构造方法主要用于子类访问父类数据的初始化。
对于成员方法来说，抽象类可以有抽象方法也可以有非抽象方法。

2.接口

interface就是接口，接口体现在对行为的抽象。
接口可以多重继承，一个类可以同时实现多个接口。
接口和接口也是继承关系，他们是多继承的。

接口的特点

类实现接口用implements
接口不能直接被实例化，实例化也是用多态。
抽象类实现接口时，可以不重写接口中的抽象方法，也就是说实现类要么重写接口中所有的抽象方法，要么是抽象类。

接口成员特点

成员变量

接口中的成员变量只能是常量，默认public static final修饰

成员方法

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

构造方法

接口没有构造方法，因为接口主要是对行为进行抽象，没有具体存在，一个类若没有父类，那默认继承自Object类（超类）

3.抽象类和接口的区别

成员区别

抽象类 常量，变量；有构造方法；有抽象方法，也有非抽象方法。
接口 常量；抽象方法。

关系区别

类与类之间 继承，单继承
类与接口之间 实现，可以单、多实现
接口与接口之间 继承，单、多继承

设计理念的区别

抽象类 对类抽象，包括属性和行为
接口主要是行为

//抽象类
public abstract class Door{
	public abstract void open();
	public abstract void close();
}
//接口
public interface Door{
	void alarm();//行为
}

4.抽象类/接口作为形参和返回值

抽象类与接口差不多

当有一个方法的形参或返回值是抽象类时，用多态形式实例化，然后再将子类返回即可。
当当有一个方法的形参或返回值是接口时，用多态形式实例化，然后再将子类返回即可。

5.内部类

//一般形式
public class Outer {
	private  int num = 10;
    public class Inner { 
        public void show(){
            System.out.println(num);
        }
    }
    }
}

内部类分为两种：
在类的成员位置叫成员内部类。
在类的方法位置交局部内部类。

//内部类的创建
public class OutDemo {
    public static void main(String[] args) {
        Outer.Inner  nnn = new Outer().new Inner();//外部类.内部类  对象名 = new 外部类().new 内部类();这种创建仅限于Inner权限为public
        nnn.show();
    }
}
//当内部类由private修饰，在外部类中创建一个方法实例化内部类并调用内部类成员方法
//类Outer
public class Outer {
    private  int num = 10;

    public class Inner {
        private void show(){
            System.out.println(num);
        }
    }
    public void method(){
        Inner n = new Inner();
        n.show();
    }
}
//main
public class OutDemo {
    public static void main(String[] args) {
        Outer n1 = new Outer();
        n1.method();
    }
}

匿名内部类，前提是存在一个类或者接口，这里的类可以是具体的类也可以是抽象类。匿名内部类实际上是一个继承了该类或者实现了该接口的子类匿名对象。

//新建jumpping接口
public interface Jumpping {
    void jump();
}
//新建jumppingOperator类调用接口方法
public class JumppingOperator {
    public void method(Jumpping j){
        j.jump();
    }
}
//现在要建一个对象，使得该对象能够调用接口中的方法，在这之前要新建一个类，实现接口中的方法，通过在main中利用多态的形式实现。
//新建Cat类
public class Cat implements Jumpping{
    @Override
    public void jump() {
        System.out.println("猫");
    }
}
//新建Dog类
public class Dog implements Jumpping{
    @Override
    public void jump() {
        System.out.println("狗");
    }
}

//新建main
public class JumppingDemo {
    public static void main(String[] args) {
        JumppingOperator j = new JumppingOperator();
        Jumpping j1 = new Cat();
        j.method(j1);

        Jumpping j2 = new Dog();
        j.method(j2);

        //用匿名内部类，就不用再像之前那样，调用方法再创建一个类。
        j.method(new Jumpping() {
            @Override
            public void jump() {
                System.out.println("cat");
            }
        });
        j.method(new Jumpping() {
            @Override
            public void jump() {
                System.out.println("dog");
            }
        });
    }
}