继承

如果父类中存在有参数的构造方法，而没有重载无参数的构造方法，那么子类中必须包含有参数的构造方法。因为如果子类中没有构造方法，默认会调用父类中无参的构造方法，但是因为父类中没有无参构造方法(默认构造参数被取消了)，那么就会出错。

public class Student extends People { // 继承父类Peopleprivate String stuNo;private String department;public Student(String name,int age,String sex,String sn,String stuno,String department) {super(name, age, sex, sn); // 调用父类的构造方法this.stuNo = stuno;this.department = department;}
}

如果类声明头部没有extends子句，那么该类就是隐含地继承了java.lang.Object类。
java只有单继承。
super关键字除了调用父类的构造方法，还可以 super. 调用父类的属性或方法。当子类有同名覆盖的时候，用 super. 可以区分。

方法重写与重载

在重写方法时，需要遵循下面的规则：

1. 参数列表和返回类型必须完全与被重写的方法参数列表相同，否则不能称其为重写。
2. 访问修饰符的限制一定要大于被重写方法的访问修饰符（public>protected>default>private）。
3. 重写方法一定不能抛出新的检査异常或者比被重写方法声明更加宽泛的检査型异常。如父类的一个方法声明了一个检査异常 IOException，在重写这个方法时就不能抛出 Exception，只能拋出 IOException 的子类异常，可以抛出非检査异常(RuntimeException与其子类，以及Error)。
4. static修饰符也不可以漏

方法重载只要求参数列表不同。

对象类型转换

原则：
1.成员变量与引用变量所声明的类型的成员变量绑定，是编译时绑定。
2.静态方法与引用变量所声明的类型的静态方法绑定，是编译时绑定。
3.非静态方法是动态绑定，由引用变量实际以用的对象决定。

例子

父类Animal：
public class Animal {public String name="Animal：动物";public static String staticName="Animal：可爱的动物";public void eat() {System.out.println("Animal：吃饭");}public static void staticEat() {System.out.println("Animal：动物在吃饭");}
}
子类Cat：
public class Cat extends Animal {public String name="Cat：猫";public String str="Cat：可爱的小猫";public static String staticName="Dog：我是喵星人";public void eat() {System.out.println("Cat：吃饭");}public static void staticEat() {System.out.println("Cat：猫在吃饭");}public void eatMethod() {System.out.println("Cat：猫喜欢吃鱼");}public static void main(String[] args) {Animal animal=new Cat(); // 引用变量animal，声明的类型是Animal，实际绑定的是Cat类Cat cat=(Cat)animal;    //向下转型System.out.println(animal.name);    //输出Animal类的name变量System.out.println(animal.staticName);    // 输出Animal类的staticName变量animal.eat();    //输出Cat类的eat()方法。非静态方法，动态绑定animal.staticEat();    //输出Animal类的staticEat()方法。静态方法静态绑定System.out.println(cat.str);    //调用Cat类的str变量System.out.println(cat.name); // Cat类的name变量System.out.println(cat.staticName); // Cat类的staticName变量cat.eatMethod();    //调用Cat类的eatMethod()方法 //非静态方法，动态绑定}
}

Java编译器允许具有直接或间接继承关系的类之间进行类型转换，对于向下转型，必须强制进行类型转换(因为可能会增加功能呀)；对于向上转型，不强制。
上例中animal是一个引用类型的变量，编译器会按照声明的类型处理。虽然它实际指向了一个Cat类实例，但是animal.str或者animal.eatMethod()这样调用子类Cat类成员和方法的话，还是编译出错的，必须强制转成Cat类。如

((Cat)animal).str="";    //编译成功
((Cat)animal).eatMethod();    //编译成功

抽象类

抽象类中必须包含至少一个抽象方法，只要包含了一个抽象方法，就要声明为抽象类。抽象类是不能new新对象的。
public abstract class XXX
abstract关键字只能用于普通方法，不能用于static方法或构造方法中。

这是一个抽象类，父类：
public abstract class Shape {protected int width; // 设置成protected方便子类访问protected int height;public Shape(int width, int height) {this.width = width;this.height = height;}public abstract double area(); // 抽象方法
}
子类Square
public class Square extends Shape{public Square(int width, int height) {super(width, height); // 调用父类构造函数}public double area() { // 重写抽象方法return width*height; // 直接用这俩变量，因为是protected}
}
子类Triangle
public class Triangle extends Shape{public Triangle(int width, int height) {super(width, height);}public double area() { // 重写抽象方法return 0.5 * width * height;}
}

接口

• 接口不能被实例化，因为它只有方法的声明而无实现，也没有构造方法。
• 接口的方法只能是抽象和公开的，不需要写修饰符。
• 接口中声明的变量其实是常量，因为隐式地声明为public static final，所以必须初始化。
• 接口本身可以有public/static/final属性。public的接口，允许任何类访问，没有指定的话，访问限制于所属的包。
• 一个类只有一个直接父类，但是可以实现多个接口。
• 一个接口不能实现另一个接口，但是它可以继承多个其他接口，子接口也可以对父接口的方法和常量进行重写。

接口定义格式：

[public] interface interface_name [extends name1[, name2,…]]

接口实现格式：

<public> class <class_name> [extends superclass_name] [implements interface[, interface…]]

如果一个类实现的接口里有同样方法，那么相同的方法将被其中任一接口使用。实现接口里方法定义的方法必须是public，且必须与定义严格匹配。
接口是对一组具有相同属性和方法的、逻辑上不相关的事物的一种抽象(like a)，但是抽象类，其实父类和子类之间还是有关系的(is a)。