JavaSE基础——代码块、继承、方法重写和final关键字

JAVA学习day08 JavaSE基础——代码块、继承、方法重写和final关键字

1.1 代码块的概述和分类

  ● 代码块的概述：
   在代码块中，被{ }括起来的代码被称为代码块。

  ● 代码块的分类：
  根据代码块位置和声明的不同，可将代码块分为局部代码块、构造代码块、静态代码快、同步代码块。
  ● 常见代码块的应用：
  （1）局部代码块：在方法中出现；限定变量声明周期，早释放，以提高内存利用率。
  （2）构造代码块：在类中方法外出现；多个构造方法中相同的代码放到一块，每次调用构造都执行，并且在构造方法前执行。
  （3）静态代码块：在类中方法外出现，并且加上static 修饰，用于给类进行初始化，在加载类的时候执行，并且只执行一次。

1.2 继承的概述

  ● 继承概述：在多个类存在相同的属性和方法时，将这些内容单独抽取出来，写到一个类中去，其他的类无需再定义这些属性和方法，只需要继承这个类即可。
  ● 继承格式：
   通过 extends 关键字实现类和类的继承；class Zi extends class Fu{ }。

1.3 继承的案例：

 学生类和老师类。定义两个功能(吃饭，睡觉)

//父类
public class Person {
    private String name;
    private int age;

    public Person(){
        System.out.println("空参的构造方法");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void eat(){
        System.out.println("在吃饭");
    }
    public void sleep(){
        System.out.println("在睡觉");
    }
}
//子类Teacher
public class Teacher extends Person{
    int jobNumber;

    public int getJobNumber() {
        return jobNumber;
    }

    public void setJobNumber(int jobNumber) {
        this.jobNumber = jobNumber;
    }

    public static void main(String[] args) {
    }
}
//子类Student
public class Student extends Person{
    int studentID;

    public int getStudentID() {
        return studentID;
    }

    public void setStudentID(int studentID) {
        this.studentID = studentID;
    }

    public static void main(String[] args) {
        Student student = new Student();
        student.setName("小明");
        student.setAge(20);
        student.setStudentID(12);
        System.out.println("姓名："+student.getName());
        System.out.println("年龄："+student.getAge());
        System.out.println("学号："+student.getStudentID());
        student.eat();
    }
}

运行子类Student：

图 1-1 运行结果截图

1.4 继承的特点和优缺点

 ● 继承的特点：
   Java 只支持单继承，不支持多继承，但可以多层继承。

 ● 继承的优缺点：
    优点：提高了代码的复用性、维护性；让类与类之间产生了关系，这是多态的前提。
    缺点：类的耦合性增强了，这有悖于开发的原则；开发的原则：高内聚，低耦合。内聚：就是类自己完成某件事情的能力，耦合：类与类的关系。

1.5 继承的注意事项

 （1）子类只能继承父类的所有非私有成员；
 （2）子类不能继承父类的构造方法，但是可以通过super关键字访问父类的构造方法。

1.6 继承中成员变量的关系

  子类中的成员变量和父类中的成员变量重名 ；在子类中访问一个变量的查找顺序（就近原则）：
    （1）在子类的局部范围找，有就使用；
    （2）在子类的成员范围找，有就使用；
    （3）在父类的成员范围找，有就使用；
    （4）如果还找不到，就报错。

1.7 this和super的区别和应用

  ● 区别：
    this 是指本类对象的引用，super 代表的是父类存储空间的标识（可以看作是父类的引用，来操作父类的成员）。
  ● 使用：
    （1）调用成员变量：this.成员变量 代表本类对象的引用；super.成员变量 代表父类的成员变量；
    （2）调用构造方法：本类的构造方法 this（…）；调用父类的构造方法 super（…）；
    （3）调用成员方法：this .成员方法 调用本类的成员方法；super .成员方法 调用父类成员方法。

小案例：（看程序写结果）

class Fu{
		public int num = 10;
		public Fu(){
			System.out.println("fu");
		}
	}
	class Zi extends Fu{
		public int num = 20;
		public Zi(){
			System.out.println("zi");
		}
		public void show(){
			int num = 30;
			System.out.println(num);
			System.out.println(this.num);
			System.out.println(super.num);
		}
	}
	class Test {
		public static void main(String[] args) {
			Zi z = new Zi();
			z.show();
		}
	}

运行结果：
 可以看到在new一个对象时，子类会先调用父类的构造方法，在子类的第一行代码系统默认有一个super();来调用父类的构造方法。

图 1-2 运行结果截图

1.8 方法重写

  ● 概述：子类中出现和父类中的一模一样的方法声明（方法名，返回值类型、参数列表），也被称为方法覆盖。
  ● 应用：当子类需要父类的方法，而方法主体有自己的特有内容时，可以重写父类中的方法。
  ● 注意事项：（1）父类中的私有方法不能被重写，私有方法根本不能被继承。
        （2）子类重写父类方法时，权限访问不能更低。
        （3）父类静态方法，子类也必须通过静态方法重写。

  案例：定义一个手机类。通过研究，我发明了一个新手机，这个手机的作用是在打完电话后，可以听天气预报。

//父类
public class Phone {
    public void call(){
        System.out.println("打电话");
    }
    public void sendMess(){
        System.out.println("发短信");
    }
}
//子类
public class newPhone extends Phone{
    public newPhone(){
        super();
    }
    public void call(){

        System.out.println("打电话"+"听天气预报");
    }
}
//测试
public class Test {
    public static void main(String[] args) {
        newPhone phone = new newPhone();
        phone.call();
    }
}

运行结果：

图 1-3 运行结果截图

1.9 final 关键字

  ● final 关键字可以用来修饰类、方法、变量和成员方法。
  ● 修饰特点：（1）修饰类：被修饰的类不能被继承；
        （2）修饰方法：被修饰的方法不能被重写；
        （3）修饰变量：变量不能被重新赋值，其实就等于一个常量。
  ● final 修饰变量：
    修饰基本类型，这个变量的值就不发生改变
    修饰引用类型，这个变量初始化之后就不能再指向别的对象了，也就是说这个变量的地址值不能再发生改变了。