java：继承、接口、抽象

1、继承 extends

    子类构造方法中，编译器调用父类的无参构造方法，所以子类的构造方法中的super()可省略。

    当父类只有有参构造方法，而子类调用父类构造，编译器只能调用有参的，则super(xxx)不可省略。

    java不支持多继承（菱形继承问题，比如类A,B是继承了Object类，类C继承了A,B类，但A,B类中有同名方法，现在就不知道到底调用的是哪个方法了   为了避免  java不支持多继承。为了弥补，Java的接口可以多实现）

2、super关键字的使用

      1 用于从派生类访问基类的成员

      2 派生类要调用基类的构造方法 super（），super（）只能在派生类的构造方法中调用，位于方法首行。

      3 调用基类已被其他方法重写的方法

      4 访问基类的数据成员：super.成员变量、super.成员方法

3、成员变量的隐藏和方法的覆盖

       

        类方法的重写应满足下列条件：

        1 派生类中该方法的返回值和基类同名方法的返回值相同，参数列表相同。

        2 派生类中的重写方法的访问权限不能比基类小。权限的顺序为：public,protected,private。

        3 基类的 abstract 方法必须被派生类重写，否则派生类也必须是 abstract

        4 基类的 final 方法不能被派生类重写。

class Animal{
    protected String name;
    protected int age;
    protected String sex;
    Animal(){};
    public Animal(String name){
        this.name =name;
    }
    public void eat(){
        System.out.println("Animal eat");
    }
}

class Cat extends Animal{
    protected String name;
    public void eat(){//覆盖父类的方法
        System.out.println("Cat eat");
    }
    public void catMice(){
        System.out.println(super.name);//访问父类的成员变量
        super.eat();//访问父类中的方法
        System.out.println(name+"catMice");
    }
}

 

4、抽象

   1、抽象类和抽象方法

    抽象类：在 Java 面向对象当中，所有的对象都是用过类进行描绘的，但是并不是所有的类都是用来描绘对象的，如果一 个类中没有包含足够的信息来描绘一个具体的对象，我们把这种类定义为抽象类。

    抽象类的特征：

    1、不能用来实例化对象，所以抽象类必须被继承才能被使用，其他功能和普通类相似。

    2、一个抽象类只能继承一个抽象类。

    3、抽象类的修饰符不能是private。

    抽象方法：如果想要设计一个类，该类包含一个特别的成员方法，该方法是根据子类的行为来确定的，那么在父类中将这个方法声明为抽象方法。继而含有抽象方法的类称为抽象类。

   

    抽象方法的特征：

    1、抽象类不一定含有抽象方法，但有抽象方法的类一定是抽象类。

    2、构造方法，类方法（static修饰的方法）不能声明成抽象方法。

    3、抽象类的子类必须给出抽象类中抽象方法的实现，除非该子类也是一个抽象类。

    4、抽象方法的修饰符不能是private。

abstract class Empployee{
    private int age;
    private String address;
    private int num;
    public Empployee(int age, String address, int num) {
        this.age = age;
        this.address = address;
        this.num = num;
    }
    public void mailCheck(){
        System.out.println("mailng a check to"+this.age+""+this.address);
    }
    public void setAddress(String newaddress){
        this.address=newaddress;
    }
    public abstract void fun();//定义抽象方法
}

class ExtendEmployee extends Empployee{
    public ExtendEmployee(int age, String address, int num) {
        super(age, address, num);
    }
    public void fun(){//抽象类方法的实现
        System.out.println("实现了抽象方法");
    }

}

public class AbstractClass {
    public static void main(String[] args) {
       // Empployee empployee = new Empployee();抽象类不能被实例化
    }
}

 

5、接口

抽象类中，可以包含一个或多个抽象方法，但在接口中，所有的方法必须是抽象的，不能有方法体。抽象类比接口更抽象。接口规定一个类必须做啥，但不规定怎么去做。

接口中声明的成员变量默认是 public static final，必须是显式的初始化。因而在常量声明时，可以省略这些修饰符。是若干常量和抽象方法的集合。

 

5.1接口性质：

1、接口中只定义抽象方法，这些方法默认是public abstract的，在声明的时候可以省略这些修饰符。

2、接口中定义实例变量，非抽象实例方法以及静态方法都是不允许的。

3、接口中没有构造方法，也不能被实例化。

4、一个接口不能实现另一个接口，但可以多继承其他接口。

5.2 接口的使用：

1、接口的使用与类的使用不同，在需要使用类的地方，会直接进行new关键字来创建一个类的实例，但接口不行。

2、接口必须通过类来实现他的抽象方法。

3、如果一个类不能实现完接口中的抽象方法，那这个类应该设计为抽象类。

4、不允许创建接口的实例，但允许定义接口类型的引用变量 引用实现该接口的类的实例。

interface InterfaceClass{
    int a = 10;//必须是public finaal int a =10；只是省略 必须进行初始化
    void fun();//public abstract fun() 只能用public abstract修饰，不能用其他
}

class AchieveInterface implements InterfaceClass{
    public  void fun(){
        System.out.println("achieve interface abstract method");
    }
}

6、向上造型

向上造型就是定义父类的引用，引用派生类的对象。

Animal animail = new Cat();

animal引用.出来的方法是父类的方法接口，但是方法的实现却是子类的实现方式。

6、1接口的使用

interface Fruit{
    public abstract void eat();
}

class  Apple implements Fruit{
    public void eat(){
        System.out.println("吃苹果");
    }
}

public class InterfaceCla {
    public static void main(String[] args) {
        Fruit f = new Apple();
        f.eat();
    }
}

本程序在主类中通过 Apple 类实例化 Fruit 接口对象，通过接口对象调用 eat 方法，调用的是被重写过的方法。 本程序在接口的实例化中明确要调用的子类对象。但是，一个父类所派生出来的子类不止一个。Class Orange implements Fruit{}. main: Fruit f=new Orange();难道每一次都要修改实例化接口的子类吗？ 在 Java 中的 JVM 为了解决程序与操作系统之间的耦合问题，在程序与操作系统之间加了一个中间过渡层-JVM，由 JVM 匹配不同的操作系统，只要 JVM 核心不变，程序就可以在任意的操作系统间进行移植。 想办法只让用户看到接口而不必看到子类： 添加一个工厂类进行过渡

class Factory{
        public static Fruit getInstance(String className){
            If(className.equals(“apple”)){
                 Return new Apple();
             }
             If(className.equals(“orange”)){
                 Return new Orange();
             }
         }
}
Main:
Fruit f=Fruit.getInstance(“apple”);
f.eat();

7、多态的实现原理

7、1发生多态的三个条件

1、继承

2、方法的重写

3、父类引用派生类对象（向上构型）

abstract class Shape{
    protected int wide;
    protected int length;
    protected int high;
    public Shape(int wide, int length, int high) {
        this.wide = wide;
        this.length = length;
        this.high = high;
    }
    public Shape(){};
    public abstract double CirCumference();//周长
}

class Rectangle extends Shape{
    public Rectangle(int wide, int length, int high) {
        super(wide, length, high);
    }
    public Rectangle(){};
    @Override
    public double CirCumference() {
        return 2*(this.high+this.length+this.wide);
    }
}

class Square extends Shape{
    public Square(int wide, int length, int high) {
        super(wide, length, high);
    }
    public Square() {
    }
    @Override
    public double CirCumference() {
        return 4*this.wide;
    }
}

public class TestDemo {
    public static void main(String[] args) {
        Shape rec = new Rectangle(10,23,90);//父类定义子类对象 向上造型
        System.out.println(rec.CirCumference());
        Square squa = new Square(10,10,10);
        System.out.println(squa.CirCumference());
    }

}

7.2 动多态（运行时多态）

运行期

注意：发生运行时多态的三个条件。

7.3 静多态

静多态称编译时多态，就是所说的方法的重载。相同的函数名，根据形参个数的不同调用

调用不同的方法。在编译期就已经确定要调用的方法。

7.4 重写和重载的区别：

1、所处的作用范围不同。重载是在同一个类中进行方法的定义，重写是在父子类中进行方法的定义。

2、其次，他们的定义方式不同。重载是方法名同，参数列表不同。而重写是方法名，参数列表相同。