1. extends
2. abstract
3. interface
4. implement

1.extends关键字

继承：已有类派生新的类，子类继承父类属性和行为，并可以扩展

class 子类 extends 父类 {}

package com.day3;

/**
* @author SFJ
* @date 2019/11/9
* @time 22:15
**/
public class Test1 {
public static void main(String[] args) {
Student student = new Student(); // 实例化的是子类
student.setName("桑凤娇"); //        Person类的方法（父类方法）
student.setAge(21); //               Person类定义
System.out.println("姓名：" + student.getName() + "，年龄：" + student.getAge());
student.setSchool("聊城大学");
System.out.println(student.getSchool());
}
}
class Person {
private String name;
private int age;
public void setName(String name) {
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return this.name;
}
public int getAge() {
return this.age;
}
}
class Student extends Person { // Student类继承了Person类
private String school; // 子类的属性
public void setSchool(String school) {
this.school = school;
}
public String getSchool() {
return this.school;
}
}

子类继承父类，将父类定义更加具体化，即父类表示范围大，子类表示的范围小

继承使用时的限制：

1.单继承：一个子类只能继承一个父类，但一个父类可被多个子类继承

1.1错误：（不能多重继承）

class A {}
class B {}
class C extends A,B {}          // 一个子类继承了两个父类

1.2正确：(C实际是（孙）子类，实现多层继承)

class A {}
class B extends A{}            // B类继承A父类
class C extends B {}          //  C子类继承B类

2.私有属性无法直接访问： 父类私有属性，子类无法直接进行访问，但是却发现可以通过setter、getter方法间接的进行操作。

package com.day3;

/**
* @author SFJ
* @date 2019/11/9
* @time 22:38
**/
public class Test2 {
public static void main(String[] args) {
B b = new B();
b.setM("sangfnegjiao");
System.out.println(b.getM());
}
}
class A {
private String m;
public void setM(String msg) {
this.m = msg;
}
public String getM() {
return this.m;
}
}
class B extends A {
public void print() {
System.out.println(m); // 错误: m定义为private，不可见
}
}

3.传递性： 在继承关系之中，实例化子类对象，会默认先调用父类构造，为父类之中的属性初始化，之后再调用子类构造，为子类之中的属性初始化，即：默认情况下，子类会找到父类之中的无参构造方法。

package com.day3;

/**
* @author SFJ
* @date 2019/11/9
* @time 22:44
**/
public class Test3 {
public static void main(String[] args) {
B1 b1 = new B1();
}
}
class A1 {
public A1() {         // 父类无参构造
System.out.println("父类无参构造方法") ;
}
}
class B1 extends A1 {
public B1() {         // 子类构造
System.out.println("子类构造方法");
}
}

   默认调用的是无参构造，而如果这个时候父类没有无参构造，则子类必须通过super()调用指定参数的构造方法:

package com.day3;

/**
* @author SFJ
* @date 2019/11/9
* @time 22:44
**/
public class Test3 {
public static void main(String[] args) {
B1 b1 = new B1();
}
}
class A1 {
public A1(String s) {         // 父类无参构造
System.out.println("父类有参构造方法"+s) ;
}
}
class B1 extends A1 {
public B1() {
super("hello");// 子类构造，super调用父类构造时，一定要放在构造方法的首行上
System.out.println("子类构造方法");
}
}

2.abstract关键字（抽象方法，抽象类）

1. 抽象类：包含抽象方法的类就是抽象类。通过abstract定义规范，然后要求子类必须定义具体实现，通过抽象类，严格限制子类的设计，使子类之间更加通用。

2. 抽象方法：使用abstract修饰的方法，无方法体，只声明。定义的是一种“规范”，就是告诉子类必须要给抽象方法提供具体的实现

注意事项：

1.在抽象方法的类只能定义成抽象类。
2.抽象类不能实例化，即不能用new来实例化对象
3.抽象类可包含属性、方法、构造方法，但构造方法不能new实例，只能被子类调用。
4.抽象类只能用来被继承
5.抽象方法必须被子类实现。   

abstract class Bird {// 抽象类:有抽象方法的类一定是抽象类

public abstract void play();// 不要{}的方法,只写方法的声明   抽象方法---作用:做了 一个简单的规则
public void run() {// 普通方法
System.out.println("run");
}
}
abstract class BadBird extends Bird {// 可以将子类变成抽象类,但是要想使用当前的类就必须再创建子类,因为抽象类不能直接创建对象
public void piay() {
// 重写方法,写抽象方法的实现
}
}

3. interface&& 4.implements

接口是抽象方法和常量值的定义的集合，是一种特殊的抽象类，这种抽象类中只包含常量和方法的定义，而没有变量和方法的实现。

public interface Study{
int id = 1
public void start()
public void run()
public void stop(）
}

一个抽象类可以继承一个抽象类，一个接口却可以使用extends同时继承多个接口（但是接口不能继承抽象类，因为如果继承抽象类的话就必须实现其中的抽象方法，而接口中只能是抽象方法）：

package com.day3;

/**
* @author SFJ
* @date 2019/11/9
* @time 23:20
**/
public class Test4 {
public static void main(String[] args) {
C4 c = new C4();
c.print();	//调用子类实现的方法
c.info();
}
}
interface B4 {
public void info();//定义抽象方法
}
interface A4{
public void print();
}
class C implements A4 {

@Override
public void print() {
System.out.println("实现接口A4的抽象方法");
}
}
class C4 implements A4,B4{
@Override
public void print() {
System.out.println("实现接口A4的抽象方法");
}
@Override
public void info() {
System.out.println("实现接口B4的抽象方法");
}
}