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关键字进行多继承。