Java 学习笔记 Day011

super 关键字

一般而言，子类覆写过父类方法后，对象优先调用子类中方法。若想让对象调用子类覆写过的方法，直接调用即可。如果需要调用父类中被子类覆写过的方法，需要通过super来调用。super.functionName();
在类的方法外部不允许使用super（super是私有的）。（不能用super.super.functionName()）。如果子类要调用父类的父类，只能寄希望 于父类有 super调用父类方法的方法。（反射 除外）

构造子类的对象时，必须调用父类的构造方法。但是如果父类没有默认构造方法，就必须显式调用父类的构造方法。
构造方法不能被继承，只能被调用。super和this一样，必须放在第一句。（super(variableName1， variableName2)）
在创建子类的对象时，每个子类的构造方法都会调用父类的构造方法。
即使你在写子类构造方法的时候没有写super()系统也会默认添加一个super()；

//创建一个person类，filename：Person.java
public class Person {
    //person有四个属性
private String name;
    private String addr;
    private int sex;
    private int age;
    public Person(String name, String addr, int sex, int age) {
        super();
        this.name = name;
        this.addr = addr;
        this.sex = sex;
        this.age = age;
    }
    public Person(String name, String addr) {
        super();
        this.name = name;
        this.addr = addr;
    }
    public Person() {
        super();
    }

}
//创建一个student类，person 是student的父类
public class Student extends Person{
    private double math;
    private double english;
    public Student(double math, double english) {
        //子类的构造方法都会调用父类的构造方法
  super();
        this.math = math;
        this.english = english;
    }
    public Student() {
    //子类的构造方法都会调用父类的构造方法
    super();
    }
    public Student(String name, String addr, int sex, int age, double math, double english) {
        //子类的构造方法都会调用父类的构造方法
  super(name, addr, sex, age);
        this.math = math;
        this.english = english;
    }
}

final 关键字

final 关键字：可以修饰变量，方法和类
用来修饰的属性都是常量，一旦赋值就不能改变
静态全局常量（public static final ）一般要求全大写，带下划线，满足驼峰法命名。
final 修饰的方法叫做最终方法，子类不可被覆写。用final 修饰的类型不能有子类。

对象数组

对象数组：由对象的引用组成的数组，称为对象数组。
对象数组用来统一管理对象。

//filename:TheMain.java
//@author: gonson
public class TheMain{
    public static void main(String[] args) {
        //创建一个对象数组
        Student[] s = new Student[5];
        for (int i = 0; i < s.length; i++) {
            s[i] = new Student("name" + i, (int)(Math.random()*11 + 10));
            System.out.println(s[i].toString());
        }
    }
}

class Student {
    private String name;
    private int age;
    public Student(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "Student [name=" + name + ", age=" + age + "]";
    }

}
/*执行结果：
Student [name=name0, age=17]
Student [name=name1, age=18]
Student [name=name2, age=16]
Student [name=name3, age=16]
Student [name=name4, age=20] */

抽象类

对对象的抽象是类；对类的抽象是 抽象类；
抽象类是一种特殊的类，用abstract 关键字修饰的类型或含抽象方法的类型
抽象方法就是用abstract 关键字修饰的且不含方法体的方法（只有方法的定义，没有方法的实现）。
抽象类不能产生自己的对象，抽象类只能当做父类来使用。
为什么要有抽象类：
不方便或者不能控制子类的方法实现时。
也没有必要去规定这个方法的具体实现过程
子类必须覆写父类的抽象方法以适应子类的需求
抽象方法必须定义在抽象类中。
子类必须覆写抽象类中的抽象方法，而且子类无法通过super调用抽象方法。
对于子类可以调用抽象方法中的非 抽象方法。
在抽象类中 非抽象方法可以调用抽象方法。

抽象类不能用final 修饰，因为用final 修饰的类型不能有子类，而抽象类只能当做父类。
抽象类可有自己的构造方法，可以有普通方法。不一定有抽象方法。（主要在多态中用的比较多）

//创建一个图形的抽象类，具有面积和周长的方法
public abstract class Shape {
    public abstract double getArea();
    public abstract double getPerimeter();
}

java接口

java接口：接口是一种特殊的抽象类；
当类中所有的方法都是抽象方法，所有的属性都是静态全局常量，这些类可以称为接口。
abstract class —-> interface （public 和abstract 在接口中可省略）

/*
创建一个图形的抽象类，具有面积和周长的方法
public abstract class Shape {
    public abstract double getArea();
    public abstract double getPerimeter();
}
*/
//上面的图形抽象，具有面积和周长的方法，可以写成接口
public interface ShapeInterface {
    double getArea();
    double getPerimeter();
}

接口里不可以有普通方法。 接口是JavaEE 中的核心。
接口主要用来描述类型的功能。
接口只能做父类，接口的子类用implement 关键字来生成，接口的子类称为接口的实现类。
接口可以多继承，也叫做多重实现。
public class className implement A,B,C {}

实现其他人规定程序的功能，叫做实现接口。将自己的程序的功能提供给别人使用叫做抛出接口。

当抽象类的子类是抽象类的时候，可以选择性覆写 父类中的抽象方法，而当抽象类的子类是普通的类是必须覆写父类中的重写方法。

抽象类可以不可以被继承。继承类后（extends）还可实现接口（implement）
接口可有自己的子接口。
java中生成子接口的时候可用extend关键字进行多继承。