Java常见关键字及其用法（下）

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的抽象方法");
    }
}