抽象类、接口和内部类

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() {

}
}
}