Java继承、多态和接口

继承

含义：可以通过扩展一个已有的类，并继承该类的属性和行为，来创建一个新的类

优点：

1）代码的重用性

2）子类扩展父类的属性和方法

3）父类的属性和方法可用于子类

4）设计应用程序变得更加简单

 

继承的实现：

　　关键字extends：用于继承其他类（extends出现在类声明类名后，extends后接要继承的类名）

                         访问修饰符   class  子类名   extends 父类名(){};

public class Employee (){}  //  父类
public class Salary extends Employee (){} // 子类

单继承与多继承、Object类：

     在Java中一个类只能有一个父类，多继承在Java中是不被允许的，但并不意味一个类没有祖父等往上的类。Object类是所有类的祖类，任何类都可以可以继承Object类(不是直接父类就是间接父类)

public class Employee (){}  //  父类
public class Salary extends Employee (){} // 子类
public class  Emp   extends Salary (){} // 子类

 

方法重写（子类对父类方法的重写）：子类可以重写父类继承的方法，从而允许子类添加或者改变父类中方法的行为

 　　　　>子类的方法返回值的类型、方法名、和形式参数列表必须和父类一致

　　　　 >子类访问修饰符不能比父类严格

　　　　 >子类抛出的异常不能多于父类

super关键字：调用父类中重写的方法

　　调用父类构造器：

　　　　>调父类构造器是第一句可执行语句

　　　　>默认情况下子类会调用父类的无参构造

　　　　>做子类构造器初始化要先做父类构造器初始化

　　格式： super.方法名（）      

 final关键字

 　　1)修饰类：不能被继承

　　 2）修饰方法：最终方法不能被重写

　　 3）修饰变量：变量值不能被修改

 类的高级概念

 静态成员：

　　关键字static 允许成员变量和方法不于类的特定实例关联，通过关键字static 声明的成员变量和方法可以被认为是全局的，任何其他类可以直接访问静态成员和调用静态方法，而不需要该类的一个实例

实例初始化块

在类的对象每次实例化时执行一次，在构造器之前执行

　　执行顺序：1）子类中相应的构造器被调用

　　　　　　　2）执行对super的调用，控制流程跳转回子类构造器

　　　　　　　3）父类构造器执行完，控制流程跳转回子类构造器

　　　　　　　4）在该子类构造器中的super（）后面的任何语句执行前，实例化初始化块执行

　　　　　　　5）执行子类构造器中super（）后面的语句

 

内部类：

　　静态内部类：

class Outer{
    static class Inner{
    }

 }

成员内部类：

class Outer{
    class Inner{
    }
}

局部内部类：

void f(){
    class Inner{
        void g(){
        }
    }
}
    

匿名内部类：
　　 

public class Outter {
    
    public void print(Inter inter){
        inter.printfInterface();
    }
}

interface Inter{
    void printfInterface();
}
public class Test {

        outter.print(new Inter(){
            @Override
            public void printfInterface() {
                System.out.println("匿名内部类打印");
            }
        });
    }
}

 

多态和抽象

多态：不同情形下的多种状态

　　分类：

　　　　>静态多态（方法重载）

　　　　>动态多态（在运行中系统才能确定方法所指对象）

　　步骤：1）编写父类派生子类

　　　　　2）子类当中重写父类方法

　　　　　3）使用多态（用父类数据类型引用子类对象）

　　　　　4）调用子类重写方法实现

　　instanceof关键字：用于判断运行时对象的真正类型

 

抽象

　　abstract关键字：　放于class之前（抽象类），不能实例化父类对象，需要被继承后才能实现

　　抽象方法：只有方法签名，没有方法主体,类也必须声明为抽象类,任何子类必须重写抽象方法，除非子类本身也是抽象

public abstract class Pet {
    private String name;        //名字
    
    public Pet() {}

    public Pet(String name) {
        super();
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "Pet [name=" + name + "]";
    }
    public abstract show();
}

接口:不能被实例化,不包含任何构造器,所有方法都是抽象的,不能包含实例成员变量,不能被一个类继承，只能被一个类实现,能够继承多个接口

 

接口声明

　　关键字：interface

public interface Board {
 public String Manufacturer(); //生产商
}

　　接口性质：

　　　　>接口默认是抽象的

　　　　>接口中的每一个方法默认也是抽象的

　　　　>默认访问级别是public

 

接口实现

　   关键字：implements

   　

public class Nboard implements Board {
    private String Manufacturer; //生产商
    
    public Nboard(String manufacturer) {
        super();
        this.Manufacturer = manufacturer;
    }

    public Nboard() {
        super();

    }

    public String Manufacturer() {

        return Manufacturer;
    }

}

　　接口与接口之间可以多重继承，只能继承一个父类

　　使用接口原则：1）使用接口解决多继承

　　　　　　　　　2）为外部类添加功能

　　　　　　　　　3）以面向对象角度考虑，将一个类与自身的特征和行为依赖于外部的可选的特征和行为分离，让类尽可能单纯

　　接口优点：将设计和实现相分离，对外（调用者)隐藏实现（而通常调用者也不需要关心实现）；面向接口编程是oop的核心

    
接口继承

public class Nboard  extends Pet implements Board {}

多重继承

public interface HockeyListener extends SportsListener{
    //实现接口中的所有方法
}
public class SportsListener implements HockeyListener {
    //也需实现六个方法
}
public interfasce HockeyListener extends SportListener,EventListener{
    //需要实现三个接口中的方法
}