抽象类、接口和内部类

7.29学习心得

1. 抽象类（abstract）

• 抽象类的特点

（1）抽象类中的方法不一定都是抽象的，抽象类中可以包含抽象的方法，也可以包含具体的方法。

（2）不能实例化抽象类。

• 抽象类有子类的时候，除非子类采用具体的方法替代抽象类中的全部抽象方法，否则子类本身也被自动被认为是抽象的。

例题1：

birds类（抽象类）：

public abstract class birds {

    private String name;
    private String sound;

    public void setName(String name)
    {
        this.name = name;
    }

    public void setSound(String sound) {
        this.sound = sound;
    }

    public void fly()
    {
        System.out.println(this.name + "弹射飞");
    }

    public void tweet() {
        if (sound.isEmpty()) {
            System.out.println("不会叫。。。");
            return;
        }
        System.out.println(sound);
    }

    public abstract void attack();

}

bomb类（爆炸鸟）：

public class bomb extends birds {

    public bomb()
    {
        super.setName("炸弹鸟");
        super.setSound("喳喳！");
    }

    public void attack()
    {
        System.out.println("炸弹攻击！");
    }
}

其他类大致与bomb类相同

main函数：

public class eee {

    public static void main(String[] args) {

        birds a = new bomb();
        a.fly();
        a.tweet();
        a.attack();

    }

}

例题2：

Shape 类（抽象类）：

public abstract class Shape {

    public abstract double getArea();

    public boolean equalArea(Shape p)
    {
        return this.getArea()==p.getArea();
    }

}

Circle 类：

public class Circle extends Shape {

    public double r;

    public Circle(double r)
    {
        this.r=r;
    }

    public double getArea()
    {
        return Math.PI*r*r;
    }

}

rectangle 类：

public class rectangle extends Shape {

    public double x;
    public double y;

    public rectangle(double x,double y)
    {
        this.x=x;
        this.y=y;
    }

    public double getArea()
    {
        return x*y;
    }
}

main 函数：

public class ddd {

    public static void main(String[] args) {

        Shape shape1=new Circle(1);
        Shape shape2=new rectangle(Math.PI,1);

        System.out.println(shape1.getArea());
        System.out.println(shape2.getArea());

        System.out.println(shape1.equalArea(shape2));
    }

}

2. 接口（interface）

• 抽象类与接口的区别

（1）接口只抽象行为。

（2）而抽象类则要指定属性、具体的方法和抽象的方法。

• 一个类可以继承自多个接口。

• 为什么Java不支持多重继承？

答：因为当一个子类从两个以上的父类继承下来的时候，可能会出现属性和方法重复或冲突的现象。

• 一个类可以继承自一个抽象类或具体类，以及多个接口。

• 子类只有将接口中声明的所有方法，以及抽象类中所有的抽象方法都进行定义，这个子类才能成为一个“具体”的类，才能实例化。

• 如果你的基础类可以不带任何属性和方法定义时，可以将它定义成一个接口。只有在必须带有属性和方法定义的时候，才采用抽象类或具体类。

• 抽象类不能用new运算符实例化，但仍应定义它的构造方法，这种构造方法将在它子类的构造方法中被调用。抽象类可以用作数据类型。

• 小结

• 接口例题：

electric 接口：

public interface electric {

    public void open(String num);

}

tv 类：

public class tv implements electric {

    public void open(String num)
    {
        System.out.println("电视接通电源" + num + "开始工作");
    }

}

main 函数：

public class work {

    public static void main(String[] args) {

        electric a = new tv();

        a.open("a");

    }

}

3. 接口与抽象类

• 接口中的数据必须是常量；抽象类中的数据可以有常量，也可以有变量。

• 接口中的方法只有一个头标志，没有实现部分；抽象类中可以有抽象的方法，也可以有具体的方法。

• 在接口中，所有的数据域都是 public final static 的，所有的方法都是 public abstract 的。

• 所有的类共享同一个根：Object类，但接口没有共同的根。

• 与类相似，接口也可以定义一个类型。

• 一个接口类型的变量可以引用任何实现该接口的类的实例。

• 如果一个类实现了一个接口，这个接口就类似于该类的一个父类。可以将一个接口当作一个数据类型使用，能够将接口类型的变量转换到它的子类，反过来也可以。

4. 内部类

• 广泛意义上的内部类一般来说包括这四种：成员内部类、局部内部类、匿名内部类和静态内部类。

• 当成员内部类拥有和外部类同名的成员变量或者方法时，会发生隐藏现象，即默认情况下访问的是成员内部类的成员。如果要访问外部类的同名成员，需要以下面的形式进行访问：

外部类.this.成员变量
外部类.this.成员方法

内部类：

class Circle {
    private double radius = 0;

    public Circle(double radius) {
        this.radius = radius;
        getDrawInstance().drawSahpe();   //必须先创建成员内部类的对象，再进行访问
    }

    private Draw getDrawInstance() {
        return new Draw();
    }

    class Draw {     //内部类
        public void drawSahpe() {
            System.out.println(radius);  //外部类的private成员
        }
    }
}

访问外部类方法：

public class Test {
    public static void main(String[] args)  {
        //第一种方式：
        Outter outter = new Outter();
        Outter.Inner inner = outter.new Inner();  //必须通过Outter对象来创建

        //第二种方式：
        Outter.Inner inner1 = outter.getInnerInstance();
    }
}

class Outter {
    private Inner inner = null;
    public Outter() {

    }

    public Inner getInnerInstance() {
        if(inner == null)
                    inner = new Inner();
        return inner;
    }

    class Inner {
        public Inner() {

        }
    }
}