Java 的继承、接口和抽象类

Java 的继承、接口和抽象类

继承

1、面向对象编程语言和面向过程编程语言最突出的特点就是变量类型的继承

2、例

class Father
{
    public void f1()
    {
        System.out.println("hello world");
    }
}

public class Main extends Father //extends是表达继承的关键字
{
    public static void main(String[] args)
    {
        Main s = new Main();
        s.f1();  //这里的f1就是继承自父类Father
    }
}

运行，输出结果为

hello world

可以看出，代码中，父类为Father，子类为Main，Main中并没有定义 f1() 方法，而是从Father中继承来的

3、通常，在面向对象的编程语言当中（C++、Java、…），当我们需要定义很多类型的时候，我们可以选取不同类型内的对象属性的共同点，将它们提取出来组成父类

4、例

public class Man extends human  
{
    public void plough()
    {
        System.out.println("plough");  //耕田
    }
    public static void main(String[] args)
    {
        Man man = new Main(); //需要new一下
        man.eat();
        man.plough();
        Woman woman = new Woman(); //需要new一下
        woman.eat();
        woman.weave();
    }
}

class human  //父类
{
    int height;
    int weight;
    public void eat(){
        System.out.println("eat");  //吃饭
    }
}

class Woman extends human  //子类
{
    public void weave()
    {
        System.out.println("weave");  //织布
    }
}

运行，输出结果

eat
plough
eat
weave

可以看出，代码中父类为Human，子类为Man和Woman，Man和Woman共同的继承了父类Human中的对象属性 height、weight 和方法 eat ；同时，Man中有独立拥有方法 plough，Woman中独立拥有方法 weave

5、综上，子类继承父类所有的属性和方法，且继承自父类的方法可以直接使用

需要注意的是，子类中不能直接访问private成员

6、与C++不同，Java中的类都只能继承一个类（C++中的类可继承多个类）

抽象类

1、

类 = 属性（0或多个）+ 方法（0或多个）

一个完整的类中，所有的方法都有实现，即类中可以没有方法，但是有方法就一定要实现

只有完整的类才可以被实例化，被new出来

如果有一个类暂时有方法未实现，就需要被定义为抽象类

2、例

public abstract class Shape//abstract是表达抽象的关键字
{
    int area;
    public abstract void S();//计算面积
}

3、抽象类的组成

——成员变量，个数不限

——具体方法，即得到实现的方法，个数不限

——抽象方法，加 abstract 关键字，个数不限

注意：

抽象类不能被new出来

比如：

abstract class A{}

A a = new A[];

是不成立的

4、抽象类可以被继承

子类需要实现父类中所有的抽象方法，如果不能完全实现，那么子类也必须被定义为抽象类

什么叫实现呢？

public void A();

这是未实现

public void A()
{
	System.out.println("hello world");
}

这是实现了

public void A(){}

这也是实现了

所以方法后面有一对大括号 { } 的，就是实现了

5、例

abstract class Shape  //abstract是表达抽象的关键字
{
    public abstract void S(); //计算面积
}

public class Main extends Shape{

    int width;
    int length;

    public Main(int length, int width) {
        this.length = length;
        this.width = width;
    }

    public void S() {
        System.out.println(this.length * this.width);
    }

    public static void main(String[] args) {
        Main rect = new Main(10,5);
        rect.S();
    }
}

运行，输出结果为

50

而，如果我们将Main中的方法S删除

abstract class Shape  //abstract是表达抽象的关键字
{
    public abstract void S(); //计算面积
}

public class Main extends Shape
{
    int width;
    int length;
    public Main(int length, int width) 
    {
        this.length = length;
        this.width = width;
    }
    public static void main(String[] args)
    {
        Main rect = new Main(10,5);
        rect.S();
    }
}

编译器将会给我们报错

所以，第4点说的很对

接口

1、如果类的所有方法都没有实现，那么这个类就算是接口 interface

​ 接口同样不能被 new 出来

​ 但是严格的说，接口不是类，接口就是接口

​ 上图展示的Java数据类型可以很明确的表达它们的关系。

2、例

public interface cpu //interface是表达接口的关键字
{
	public void work();
	public void break();
}

3、前面说，类只能继承（extends）一个类，但是可以实现（implements）多个接口，且继承与实现可以同时使用

4、同样的，类实现接口，就必须实现所有未实现的方法，如果没有全部实现，那么只能成为一个抽象类

5、例

interface cpu //interface是表达接口的关键字
{
    void work();
    void stop();
}

public class Main implements cpu //implements是表达实现的关键字
{ 
    public void work()
    {
        System.out.println("i am working");
    }
    public void stop()
    {
        System.out.println("i am stopping");
    }
    public static void main(String[] args)
    {
        Main a = new Main();
        a.work();
        a.stop();
    }
}

运行，输出结果为

i am working
i am stopping