Java语言（面向对象2（代码块、继承、方法重写、关键字（Super、final））

Java语言

面向对象

代码块

1. 代码块概述：
   在Java中，使用{}括起来的代码被称为代码块。
2. 代码块分类：
   根据其位置和声明的不同，可以分为局部代码块，构造代码块，静态代码块，同步代码块；
3. 常见代码块的应用：
   a:局部代码块
   在方法中出现；限定变量生命周期，及早释放，提高内存利用率；
   b:构造代码块
   在类中方法外出现；多个构造方法方法中相同的代码存放到一起，每次调用构造都执行，并且在构造方法前执行；
   c:静态代码块
   在类中方法外出现，并加上static修饰；用于给类进行初始化，在加载的时候就执行，并且只执行一次。

//代码块执行的顺序问题
class Test3 {
    public static void main(String[] args) {
        Zi z = new Zi();
    }
}
class Fu {
    static {
        System.out.println("静态代码块Fu");
    }

    {
        System.out.println("构造代码块Fu");
    }

    public Fu() {
        System.out.println("构造方法Fu");
    }
}

class Zi extends Fu {
    static {
        System.out.println("静态代码块Zi");
    }

    {
        System.out.println("构造代码块Zi");
    }

    public Zi() {
        System.out.println("构造方法Zi");
    }
}
/*运行结果：
静态代码块Fu
静态代码块Zi
构造代码块Fu
构造方法Fu
构造代码块Zi
构造方法Zi
*/

继承

1. 概述：
   多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。
2. 继承格式：
   通过extends关键字可以实现类与类的继承；
   class 子类名 extends 父类名 {}
   单独的这个类称为父类，基类或者超类；这多个类可以称为子类或者派生类。

//我们定义一个父类为：人类（Person），两个子类一个是老师，一个是学生；让这两个子类分别继承父类
public class Person {
    String name;
    String age;
    public void sleep(){
        System.out.println("人类都要吃饭--");
    }
    public void eat(){
        System.out.println("人类都要睡觉--");
    }
}

//子类1老师Teacher，继承父类Person
public class Teacher extends Person {
    public void teach(){
        System.out.println("老师教书");
    }
}

//子类2学生Student，继承父类Person
public class Student extends Person {
    public void study(){
        System.out.println("学生学习");
    }
}

//测试：
public class Test {
    public static void main(String[] args) {
        Teacher teacher = new Teacher();
        teacher.name="张三";
        teacher.age="30";
        System.out.println(teacher.name);
        System.out.println(teacher.age);
        teacher.eat();
        teacher.sleep();
        teacher.teach();
        System.out.println("-------------");
        Student student = new Student();
        student.name="李四";
        student.age="18";
        System.out.println(student.name);
        System.out.println(student.age);
        student.eat();
        student.sleep();
        student.study();
    }
}
/*运行结果：
张三
30
人类都要睡觉--
人类都要吃饭--
老师教书
-------------
李四
18
人类都要睡觉--
人类都要吃饭--
学生学习
*/

3. 继承的好处：
   a:提高了代码的复用性
   b:提高了代码的维护性
   c:让类与类之间产生了关系，是多态的前提
4. 继承的弊端：
   类的耦合性增强了。
   开发的原则：高内聚，低耦合。
   耦合：类与类的关系；
   内聚：自己完成某件事情的能力
5. Java中类的继承特点：
   (1)Java只支持单继承，不支持多继承；有些语言是支持多继承，格式：extends 类1,类2,…
   (2)Java支持多层继承(继承体系)；
6. 继承的注意事项:
   a:子类只能继承父类所有非私有的成员(成员方法和成员变量)；
   b:子类不能继承父类的构造方法，但是可以通过super关键字去访问父类构造方法；
   c:不要为了部分功能而去继承
7. 什么时候使用继承:
   继承其实体现的是一种关系：“is a” .
   假设:如果有两个类A,B。只有他们符合A是B的一种，或者B是A的一种，就可以考虑使用继承。
8. 在子类中访问一个变量的查找顺序(“就近原则”)
   a: 在子类的方法的局部范围找,有就使用
   b: 在子类的成员范围找,有就使用
   c: 在父类的成员范围找,有就使用
   d:如果还找不到,就会报错

• super关键字

1. 子类局部范围访问父类成员变量
2. this和super的区别
   this： 代表的是本类对象的引用
   super：代表的是父类存储空间的标识(可以理解成父类的引用,可以操作父类的成员)
3. this和super的使用
   a:调用成员变量
   this.成员变量 调用本类的成员变量
   super.成员变量 调用父类的成员变量
   b:调用构造方法
   this(…) 调用本类的构造方法
   super(…) 调用父类的构造方法
   c:调用成员方法
   this.成员方法 调用本类的成员方法
   super.成员方法 调用父类的成员方法

//查找顺序演示：
public class Test2 {
    public static void main(String[] args) {
        Son son = new Son();
        son.show(10);
    }
}
//定义父类
class Father{
    int num=200;
}
//子类继承父类
class Son extends Father{
    int num=100;
    public void show(int num){
//就近原则：当方法中去访问变量时，先在局部范围找，如果找到就使用。如果找不到，就去本类的成员范围找，找到就使用
//如果本类找不到，还会去父类里面找，找到就使用
    System.out.println(num);//10，这个num找到最近的show方法中的num；
    System.out.println(this.num);//100，这个num由于this的存在，故要找本类中的成员变量即100
    System.out.println(super.num);//200，这个num由于super的存在，故要访问父类成员变量即200
    }
}
/*运行结果：
10
100
200
*/

• 继承中的构造方法

1. 因为子类会继承父类中的数据，可能还会使用父类的数据；所以，子类初始化之前，一定要先完成父类数据的初始化；故子类中所有的构造方法默认都会访问父类中空参数的构造方法。
2. 每一个构造方法的第一条语句默认都是：super()；
   父类没有无参构造方法,子类怎么办?
   a: 在父类中添加一个无参的构造方法
   b:子类通过super去显示调用父类其他的带参的构造方法
   c:子类通过this去调用本类的其他构造方法，本类其他构造也必须首先访问了父类构造
   【注意】super(…)或者this(….)必须出现在第一条语句上

• 方法重写

1. 概述：类中出现了和父类中一模一样的方法声明(方法名,参数列表,返回值类型)，也被称为方法覆盖，方法复写。
2. Override和Overload：
   Override（重写） ：子类对父类中允许访问的方法的重载编写，也就是子类对父类的方法不满足，需要重载编写；
   Overload（重载）：是同一类中方法方法名相同，但返回值类型或参数有所不同方法的重新加载；

区别点	重载方法	重写方法
方法名	相同	相同
返回值类型	可以修改	相同
参数	参数不同或参数顺序不同	相同
访问修饰符	没要求	不能比父类的严格
范围	同一类中	在继承中

3. 方法重写的应用：
   当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法。
   这样，即沿袭了父类的功能，又定义了子类特有的内容。
4. 注意事项
   a:父类中私有方法不能被重写
   因为父类私有方法子类根本就无法继承
   b:子类重写父类方法时，访问权限不能更低，最好就一致
   c:父类静态方法，子类也必须通过静态方法进行重写，其实这个算不上方法重写，但是现象确实如此，
   d:子类重写父类方法的时候，最好声明一模一样。

• final关键字

1. 由于继承中有一个方法重写的现象,而有时候我们不想让子类去重写父类的方法.这对这种情况java就给我们提供了一个关键字: final
2. 概述：final关键字是最终的意思，可以修饰类，变量，成员方法。
3. final修饰特点
   修饰类: 被修饰类不能被继承
   修饰方法: 被修饰的方法不能被重写
   修饰变量: 被修饰的变量不能被重新赋值,这个量变为一个常量
4. final关键字修饰局部变量
   基本类型，是值不能被改变
   引用类型，是地址值不能被改变，对象中的属性可以变

例题：
将下面的描述用java语言实现：（要求包含以下内容）
父类：成员变量，成员方法
子类：重写方法，特有方法
测试类：普通调用
动物类里有很多种动物：
比如狗，猫等。
狗有姓名和年龄，猫也有姓名和年龄。
狗有跑步的方法，猫也有跑步的方法。而且都仅仅是跑步。
狗有吃饭的方法，猫也有吃饭的方法。只不过，狗吃骨头，猫吃鱼。

//Animal为父类：
public class Animal {
    int age;
    String name;
    public void eat(){}
    public void run(){
        System.out.println("跑步");
    }
}

//Cat为子类1：
public class Cat extends Animal {
    @Override//重写方法：
    public void eat() {
        System.out.println("猫吃鱼");
    }
    //特有方法：
    public void zhuanquan(){
        System.out.println("猫转圈");
    }
}
//Dog为子类2：
public class Dog extends Animal{
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
    public void lookdoor(){
        System.out.println("狗看门");
    }
}

//测试类：
public class Test {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.name="汤姆";
        cat.age=3;
        System.out.println(cat.name);
        System.out.println(cat.age);
        cat.run();
        cat.eat();
        cat.zhuanquan();
        System.out.println("------------");
        Dog dog = new Dog();
        dog.name="布鲁斯";
        dog.age=5;
        System.out.println(dog.name);
        System.out.println(dog.age);
        dog.run();
        dog.eat();
        dog.lookdoor();
    }
}
/*运行结果：
汤姆
3
跑步
猫吃鱼
猫转圈
------------
布鲁斯
5
跑步
猫吃鱼
狗看门
*/

//下篇再见…谢谢