Java常见关键字及其用法(下)

原创
2019/11/09 23:30
阅读数 163
  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的抽象方法");
    }
}

 

 

 

展开阅读全文
加载中
点击引领话题📣 发布并加入讨论🔥
打赏
0 评论
0 收藏
1
分享
返回顶部
顶部