###代码块与继承

###代码块与传承

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

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

#3、继承案例演示以及继承的好处和弊端
继承的好处与弊端：
继承的好处：（1）提高了代码的复用性
（2）提高代码的维护性
（3）让类与类产生关系，是多态的体现
继承的弊端：（1）类的耦合性增加了
继承的注意事项：（1）子类只能继承父类所有非私有的成员
(成员方法和成员变量)
（2）子类不能继承父类的构造方法，
（3）不要为了部分功能而去继承
继承的使用环境：继承其实体现的是一种关系：“is a” .
采用假设法。如果有两个类A,B。只有他们符合A是B
的一种，或者B是A的一种，就可以考虑使用继承。

案例演示：例如动物类

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//
package org.westos.demo2;
public class Animal {
    public String name;
    public int age;
    public Animal() {
    }
    public void eat() {
        System.out.println("吃饭饭");
    }
    public void sleep() {
        System.out.println("睡觉觉");
    }
}
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//
package org.westos.demo2;

public class Cat extends Animal {
    public Cat() {
    }

    public void catchMouse() {
        System.out.println("猫抓老鼠");
    }
}
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//
package org.westos.demo2;
public class Dog extends Animal {
    public Dog() {
    }
    public void lookDoor() {
        System.out.println("狗看门");
    }
}
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//
package org.westos.demo2;
public class MyTest {
    public MyTest() {
    }
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.name = "旺财";
        dog.age = 12;
        System.out.println(dog.name + "===" + dog.age);
        dog.eat();
        dog.sleep();
        System.out.println("-----------");
        Cat cat = new Cat();
        cat.name = "汤姆";
        cat.age = 3;
        System.out.println(cat.name + "===" + cat.age);
        cat.eat();
        cat.sleep();
    }
}

#4 继承中成员变量的关系
子类中的成员变量和父类中的成员变量名称不一样
子类中的成员变量和父类中的成员变量名称一样
在子类中访问一个变量的查找顺序(“就近原则”)
在子类的方法的局部范围找,有就使用
在子类的成员范围找,有就使用
在父类的成员范围找,有就使用
如果还找不到,就报错

#5、this和super的区别和应用
this和super的区别
this 代表的是本类对象的引用
super代表的是父类存储空间的标识(可以理解成
父类的引用,可以操作父类的成员)
this和super的使用
:调用成员变量
this.成员变量 调用本类的成员变量
super.成员变量 调用父类的成员变量
调用构造方法
this(…) 调用本类的构造方法
super(…) 调用父类的构造方法
调用成员方法
this.成员方法 调用本类的成员方法
super.成员方法 调用父类的成员方法

#6、继承中构造方法的关系
子类中所有的构造方法默认都会访问父类中空参
数的构造方法因为子类会继承父类中的数据，可
能还会使用父类的数据。所以，子类初始化之前，
一定要先完成父类数据的初始化。每一个构造方
法的第一条语句默认都是：super()

#7、继承中成员方法关系
案例演示：当子类的方法名和父类的方法名不一样的时候
当子类的方法名和父类的方法名一样的时候
通过子类调用方法:
a: 先查找子类中有没有该方法,如果有就使用
b:在看父类中有没有该方法,有就使用
c: 如果没有就报错

#8、方法重写概述及其应用
方法重写：
子类中出现了和父类中一模一样的方法声明(方法名,
参数列表,返回值类型)也被称为方法覆盖，方法复写。
方法重写的应用：
当子类需要父类的功能，而功能主体子类有自己特有
内容时，可以重写父类中的方法。这样，即沿袭了父
类的功能，又定义了子类特有的内容。

案例演示
定义一个学生类

package com.baiduMydemo6;

/**
 * @Author: dell
 * @CreateTime: 2018-12-12 12:03
 */
public class test1 {
    public static void main(String[] args) {
        student student = new student();
        student.setAge(17);
        student.setGrade(17);
        System.out.println(student.getName());
        System.out.println(student.getColar());
        System.out.println(student.getGrade());
        System.out.println(student.getAge());

    }
}

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package org.westos.demo3;

public class MyTest {
    public MyTest() {
    }

    public static void main(String[] args) {
        Student student = new Student();
        student.setName("胡兵");
        student.setAge(18);
        System.out.println("姓名" + student.getName() + "年龄" + student.getAge());
        student.eat();
        student.sleep();
        student.playGame();
        student.talkLove();
        Student student1 = new Student("裴艳霞", 18);
        System.out.println("姓名" + student1.getName() + "年龄" + student1.getAge());
        student1.eat();
        student1.sleep();
        student1.playGame();
        student1.talkLove();
        Teacher teacher = new Teacher("沈大叔", 23);
        System.out.println(teacher.getName() + "===" + teacher.getAge());
        teacher.eat();
        teacher.sleep();
        teacher.teache();
    }
}

     。

#9、方法重写的注意事项
方法重写注意事项
父类中私有方法不能被重写
因为父类私有方法子类根本就无法继承
子类重写父类方法时，访问权限不能更低
最好就一致
父类静态方法，子类也必须通过静态方法进行重写
其实这个算不上方法重写，但是现象确实如此，至
于为什么算不上方法重写，多态中我会讲解
子类重写父类方法的时候，最好声明一模一样。
B:案例演示
方法重写注意事项

#10、使用继承后的老师案例

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package org.westos.demo3;
public class MyTest {
    public MyTest() {
    }
    public static void main(String[] args) {
        Student student = new Student();
        student.setName("胡兵");
        student.setAge(18);
        System.out.println("姓名" + student.getName() + "年龄" + student.getAge());
        student.eat();
        student.sleep();
        student.playGame();
        student.talkLove();
        System.out.println("------------------------");
        Student student1 = new Student("裴艳霞", 18);
        System.out.println("姓名" + student1.getName() + "年龄" + student1.getAge());
        student1.eat();
        student1.sleep();
        student1.playGame();
        student1.talkLove();
        System.out.println("------------------------------");
        Teacher teacher = new Teacher("沈大叔", 23);
        System.out.println(teacher.getName() + "===" + teacher.getAge());
        teacher.eat();
        teacher.sleep();
        teacher.teache();
    }
}

#11、final关键字概述
final产生的原因：由于继承中有一个方法重写的现象,而有时候
我们不想让子类去重写父类的方法.这对这种情况java就给
我们提供了一个关键字: final
final概述
final关键字是最终的意思，可以修饰类，变量，成员方法。

#12、final关键字修饰类,方法以及变量的特点
final修饰特点
修饰类: 被修饰类不能被继承
修饰方法: 被修饰的方法不能被重写
修饰变量: 被修饰的变量不能被重新赋值,因为这个量其
实是一个常量
案例演示
final修饰特点

#13、 final关键字修饰局部变量
A:案例演示
基本类型，是值不能被改变
引用类型，是地址值不能被改变