继承

  • 基本概念

    当多个类之间拥有相同的特征和行为时，可以将相同的内容提取出来组成一个公共类，让多个类分别吸收公共类中已有的特征和行为，而在多个类中只需要编写自己独有特征和行为的机制，就叫做继承。

    使用继承可以提高代码的复用性、扩展性以及可维护性。

    在Java语言中使用extends(扩展)关键字来表达继承关系。

    如：public class Worker extends Person{} -表示Worker类继承自Person类

    其中Person类叫做基类、父类以及超类。

    其中Worker类叫做派生类、子类以及孩子类。

  • 注意事项

    (1)子类不可以继承父类的构造方法和私有方法，私有特征可以继承但不能访问；

    (2)当构造子类对象时会自动调用父类的无参构造方法来初始化从父类中继承下来的成员变量，相当于在子类构造方法的第一行增加代码：super()的效果；

    (3)Java语言中只支持单继承，也就是一个子类只能有一个父类，一个父类可以有多个子类。

    (4)使用继承必须满足逻辑关系：子类 is a 父类。

方法的重写(Override)

  • 基本概念

    从父类中继承下来的方法不足以满足子类的需求时，就需要在子类中重新写一个与父类一样的方法来覆盖从父类中继承下来的版本，该方式就叫做方法的重写。

  • 方法重写的原则(笔试题)

    a.要求方法名相同、参数列表相同、返回值类型相同，jdk1.5开始可以返回子类类型。

    b.要求访问权限不能变小，可以相同或者变大。

    c.要求不能抛出更大的异常(异常机制)。

访问控制

  • 常用的访问控制符(笔试题)

    访问控制符 访问权限 本类内部 本包中的类 子类 其它包中类
    public 公有的 ok ok ok ok
    protected 保护的 ok ok ok no
    啥也不写 默认的 ok ok no no
    private 私有的 ok no no no

  • 要求大家掌握的内容

    a.private修饰的内容只能在本类中使用。

    b.public修饰的内容可以在任意位置使用。

    c.通常情况下，成员变量由private修饰，成员方法由public修饰。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
/*
   编程实现Person类的封装
*/
public class Person {
  private String name;
  private int age;

  public Person() {
    System.out.println("Person()");
  }
  public Person(String name, int age) {
   System.out.println("Person(String, int)");
   setName(name);
   setAge(age);
  }

  public String getName() {
    return name;
  }
  public void setName(String name) {
    this.name = name;
  }
  public int getAge() {
    return age;
  }
  public void setAge(int age) {
    if(age > 0 && age < 150) {
        this.age = age;
    } else {
        System.out.println("年龄不合理！！！");
    }
  }

  public void show() {
    System.out.println("我是" + getName() + "，今年" + getAge() + "岁了！");
  }
  // 自定义成员方法实现吃饭行为的描述
  public void eat(String food) {
    System.out.println(food + "真好吃！");
  }
  // 自定义成员方法实现娱乐行为的描述
  public void play(String game) {
    System.out.println(game + "真好玩！");
  }

  // 自定义静态成员方法
  public static void test() {
    System.out.println("父类中的静态方法！");
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
/*
   编程实现Worker类的封装继承自Person类
*/
public class Worker extends Person {
  private int salary;

  public Worker() {
    super(); // 表示调用父类的无参构造方法
    System.out.println("Worker()");
  }
  public Worker(String name, int age, int salary) {
    super(name, age); // 表示调用父类的有参构造方法
    System.out.println("Worker(String, int, int)");
    //setName(name);
    //setAge(age);
    setSalary(salary);
  }

  public int getSalary() {
    return salary;
  }
  public void setSalary(int salary) {
    if(salary >= 2120) {
        this.salary = salary;
    } else {
        System.out.println("薪水不合理！！！");
    }
  }

  // 自定义成员方法描述工作的行为
  public void work() {
     System.out.println("正在努力工作...");
  }

  //标注，用于说明下面的方法是对父类中方法的重写，若没有构成重写则编译报错
  @Override
  public void show() {
    super.show(); // 表示调用父类中被重写的方法
    System.out.println("我的薪水是：" + getSalary());
  }

  public static void test() {
    System.out.println("子类中的静态方法！");
  }
}

final关键字(重点)

  • 基本概念

    final本意为"最终的，不可更改的"，该关键字可以修饰类、成员方法以及成员变量等。

  • 使用方式

    final关键字修饰类体现在该类不能被继承。-主要用于防止滥用继承，如：java.lang.String类等

    final关键字修饰成员方法体现在该方法不能被重写可以被继承。-主要用于防止不经意间造成方法的重写。如：java.text.DateFormat类format方法等

    final关键字修饰成员变量体现在该变量必须初始化而且不能更改。-主要用于防止不经意间造成数值的改变。如：java.lang.Thread类中的MAX_PRIORITY等

  • 扩展

    在以后的开发中很少单独使用static或final关键字修饰成员变量，

    通常都是使用public static final共同修饰成员变量来表达常量的含义，

    常量的命名规则就是所有字母大写不同单词之间采用下划线连接，如：public static final double PI = 3.14;

1
2
3
4
5
6
7
8
9
public class FinalMemberTest {
  private final int cnt = 0;

  public static void main(String[] args) {
    FinalMemberTest fmt = new FinalMemberTest();
    System.out.println("fmt.cnt = " + fmt.cnt);  // 0
    //fmt.cnt = 1; error
  }
}

包的定义

package 包名;
package 包名1.包名2...包名n;

包的命名为公司网址倒着写,然后加上项目名.如:cn.xdl.demo