黑马程序员---java基础-Java类 继承&抽象&接口

一、继承

 

继承是所有OOP语言不可缺少的部分，在java中使用extends关键字来表示继承关系。当创建一个类时，总是在继承，如果没有明确指出要继承的类，就总是隐式地从根类Object进行继承。比如下面这段代码：

class Person {
    public Person() {
         
    }
}
class Man extends Person {
    public Man() {
         
    }
}

类Man继承于Person类，这样一来的话，Person类称为父类（基类），Man类称为子类（导出类）。如果两个类存在继承关系，则子类会自动继承父类的方法和变量，在子类中可以调用父类的方法和变量。在java中，只允许单继承，也就是说 一个类最多只能显示地继承于一个父类。但是一个类却可以被多个类继承，也就是说一个类可以拥有多个子类。

1.子类继承父类的成员变量

　　当子类继承了某个类之后，便可以使用父类中的成员变量，但是并不是完全继承父类的所有成员变量。具体的原则如下：

 

　　1）能够继承父类的public和protected成员变量；不能够继承父类的private成员变量；

　　2）对于父类的包访问权限成员变量，如果子类和父类在同一个包下，则子类能够继承；否则，子类不能够继承；

　　3）对于子类可以继承的父类成员变量，如果在子类中出现了同名称的成员变量，则会发生隐藏现象，即子类的成员变量会屏蔽掉父类的同名成员变量。如果要在子类中访问父类中同名成员变量，需要使用super关键字来进行引用。

 

2.子类继承父类的方法

　　同样地，子类也并不是完全继承父类的所有方法。

　　1）能够继承父类的public和protected成员方法；不能够继承父类的private成员方法；

　　2）对于父类的包访问权限成员方法，如果子类和父类在同一个包下，则子类能够继承；否则，子类不能够继承；

　　3）对于子类可以继承的父类成员方法，如果在子类中出现了同名称的成员方法，则称为覆盖，即子类的成员方法会覆盖掉父类的同名成员方法。如果要在子类中访问父类中同名成员方法，需要使用super关键字来进行引用。

 

**注意：隐藏和覆盖是不同的。隐藏是针对成员变量和静态方法的，而覆盖是针对普通方法的。

 

3.构造器

子类是不能够继承父类的构造器，但是要注意的是，如果父类的构造器都是带有参数的，则必须在子类的构造器中显示地通过super关键字调用父类的构造器并配以适当的参数列表。如果父类有无参构造器，则在子类的构造器中用super关键字调用父类构造器不是必须的，如果没有使用super关键字，系统会自动调用父类的无参构造器。看下面这个例子就清楚了：

class Shape {
    protected String name;
    public Shape(){
        name = "shape";
    }
    public Shape(String name) {
        this.name = name;
    }
}
 
class Circle extends Shape {
    private double radius;
    public Circle() {
        radius = 0;
    }
    public Circle(double radius) {
        this.radius = radius;
    }
    public Circle(double radius,String name) {
        this.radius = radius;
        this.name = name;
    }
}

这样的代码是没有问题的，但是如果把父类的无参构造器去掉，则下面的代码必然会出错，

所以应该修改为：

class Shape {
    
    protected String name;
    /*
    public Shape(){
        name = "shape";
    }
    */
    public Shape(String name) {
        this.name = name;
    }
}
 
class Circle extends Shape {
     
    private double radius;
     
    public Circle() {
        super("cicle");
        radius = 0;
    }
     
    public Circle(double radius) {
        super("cicle");
        this.radius = radius;
    }
     
    public Circle(double radius,String name) {
        super("cicle");
        this.radius = radius;
        this.name = name;
    }
}

4.super

　　super主要有两种用法：

　　1）super.成员变量/super.成员方法;

　　2）super(parameter1,parameter2....)

 

第一种用法主要用来在子类中调用父类的同名成员变量或者方法；第二种主要用在子类的构造器中显示地调用父类的构造器，要注意的是，如果是用在子类构造器中，则必须是子类构造器的第一个语句。

二、抽象

 

1、特点：

由abstract修饰，描述类和方法；作为方法的声明，不具体实现

抽象类至少含有一个抽象方法，可有非抽象方法，但不可被实例化，

子类单继承抽象父类，必须实现所有抽象方法才能实例化，否则子类仍为抽象的。

2、细节：

<1.抽象类可以有构造函数，是用于对子类对象的初始化

<2.可定义非抽象方法：抽象类是对事物的描述，只是含有不具体的功能而已，所以抽象类仍需定义属性和行为的。

<3.abstract不可以和final，private，static共存。

<4.抽象类中可不定义抽象方法，抽象的目的是为了不让该类创建对象。

<5.子类继承抽象父类的非抽象方法

例：

abstract class fu {
    private fu() {
   } // ok

   fu( int a) {
   }
    static void show(){}  //ok
    //abstract int show();  //向上重名
    abstract int show(int a);  //ok
}

public class Test01 {
    public static void main(String[] args) {
          //fu f = new fu(); //无法实例化抽象
                      zi z = new zi(1);
          z.show();  //子类继承抽象父类的非抽象方法
   }
}

//继承
abstract class zia extends fu{

   zia( int a) {
          super(a);
          // TODO Auto-generated constructor stub
   }
   
}

class zi extends fu{

   zi( int a) {
          super(a);
          // TODO Auto-generated constructor stub
   }

    @Override
    int show(int a) {
          // TODO Auto-generated method stub
          return 0;
   }
   
}

三、接口

 

接口：初期理解，可以认为是一个特殊的抽象类

     当抽象类中的方法都是抽象的，那么该类可以通过接口的形式来表示。

class用于定义类

interface 用于定义接口。

 

接口定义时，格式特点：

1，接口中常见定义：常量，抽象方法。

2，接口中的成员都有固定修饰符。

     常量：public static final  接口中的量都终态的

     方法：public abstract

记住：接口中的成员都是public的。

 

接口：是不可以创建对象的，因为有抽象方法。

需要被子类实现，子类对接口中的抽象方法全都覆盖后，子类才可以实例化。

否则子类是一个抽象类。

 

接口可以被类多实现，也是对多继承不支持的转换形式。java支持多实现

 

抽象类有构造函数，而接口无构造函数

interface A {
       double a = 1; // 自动加了 终态 public
       // 常量：public static final
       public static final double PI = 3.14;
       //A(){}  //没有
       void showA();  //自动加了 抽象 public
}

class Test implements A {
       private void show() {
             // a = PI; //不能给a赋值，a默认终态
            System. out.println(a); // ok
      }
       @Override
       public void showA() {
             // TODO Auto-generated method stub
      }
}

abstract class B implements A{
      B(){} //ok
       double b = PI; //ok
       public void showA() {//实现接口的方法 权限必须是 public
      }
}

接口的特点：

l 接口是对外暴露的规则

l 接口是程序的功能拓展

l 接口可以用来多实现

l 类与接口之间是实现关系，而且类可以在继承一个类的同时实现多个接口

l 接口与接口之间可以有继承关系

 

abstract class student
{
    abstract void study();
    void sleep(){
    System.out.printlb("sleep");
    }
}
interface Smoking
{
    void smoke();
}
class ZhangSan extends Student implements Smoking
{
    void study(){}
    public void smoke(){}
}
class LiSi extends Student
{
}
//基本功能定义在类中，扩展功能定义在接口中
//需要就实现一下，不需要就算了
//清楚什么是主体，这么是副业，在体系外就用接口来表示
abstract class Sporter
{
    abstract void play();
}
interface StudyJava
{
}
class WangWU extends Sporter implements StudyJava
{
}
class StudentDemo 
{
    public static void main(String[] args) 
    {
        System.out.println("Hello World!");
    }
}