继承
含义：可以通过扩展一个已有的类，并继承该类的属性和行为，来创建一个新的类
优点：
1）代码的重用性
2）子类扩展父类的属性和方法
3）父类的属性和方法可用于子类
4）设计应用程序变得更加简单
继承的实现：
关键字extends：用于继承其他类（extends出现在类声明类名后，extends后接要继承的类名）
访问修饰符 class 子类名 extends 父类名(){};
1 public class Employee (){} // 父类
2 public class Salary extends Employee (){} // 子类
单继承与多继承、Object类：
在Java中一个类只能有一个父类，多继承在Java中是不被允许的，但并不意味一个类没有祖父等往上的类。Object类是所有类的祖类，任何类都可以可以继承Object类(不是直接父类就是间接父类)
1 public class Employee (){} // 父类
2 public class Salary extends Employee (){} // 子类
3 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(){
}
}
}
匿名内部类：
1 public class Outter {
2
3 public void print(Inter inter){
4 inter.printfInterface();
5 }
6 }
7
8 interface Inter{
9 void printfInterface();
10 }
11 public class Test {
12
13 outter.print(new Inter(){
14 @Override
15 public void printfInterface() {
16 System.out.println("匿名内部类打印");
17 }
18 });
19 }
20 }
多态和抽象
多态：不同情形下的多种状态
分类：
>静态多态（方法重载）
>动态多态（在运行中系统才能确定方法所指对象）
步骤：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
1 public class Nboard implements Board {
2 private String Manufacturer; //生产商
3
4 public Nboard(String manufacturer) {
5 super();
6 this.Manufacturer = manufacturer;
7 }
8
9 public Nboard() {
10 super();
11
12 }
13
14 public String Manufacturer() {
15
16 return Manufacturer;
17 }
18
19 }
接口与接口之间可以多重继承，只能继承一个父类
使用接口原则：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{
//需要实现三个接口中的方法
}