面向对象（三）：代码块；类的继承（格式、利弊、特点、注意、super关键字、继承中构造方法关系、方法重写）；final关键字

面向对象（三）

一、代码块

1、代码块的概述及分类

A:代码块概述：在Java中，使用{}括起来的代码被称为代码块。
B：代码块的分类及应用：
	a：局部代码块：在方法中出现，限定生命周期，及早释放，提高内存利用率；
	b：构造代码块：在类中方法外出现，将多个构造方法中相同的代码存放在一起，每次调用构造方法都会执行一次，并且在构造方法前执行；
	c：静态代码块：在类中方法外出现，使用static修饰，用于给类进行初始化，在类加载时就会执行，且只执行一次；
	d:同步代码块

2、例题：看程序写结果

	class Student {
		static {
			System.out.println("Student 静态代码块"); //3
		}
		
		{
			System.out.println("Student 构造代码块"); //4  // 6
		}
		
		public Student() {
			System.out.println("Student 构造方法"); //5 //7
		}
	}

public class StudentDemo {
		static {
			System.out.println("StudentDemo的静态代码块"); //1 
		}
		
		public static void main(String[] args) {
			System.out.println("我是main方法"); // 2  
			
			Student s1 = new Student();
			Student s2 = new Student();
		}
	}
答案：
StudentDemo的静态代码块
我是main方法
Student 静态代码块
Student 构造代码块
Student 构造方法
Student 构造代码块
Student 构造方法

二、类的继承

1、概述及格式

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

2、继承的利弊

继承的好处：
	a:提高了代码的复用性；
	b:提高了代码的维护性；
	c:让类与类之间产生了关系，是多态的前提
继承的弊端：
	增强了类的耦合性（类与类之间的关系）

3、继承的特点

Java中类的继承特点
	a:Java只支持单继承，不支持多继承;
	b:Java支持多层继承(继承体系)

举例：

//定义父类
class  Animal{
    String name;    //定义动物名字
    //定义动物叫声方法
    void Shout(){
        System.out.println("动物发出的叫声");
    }
}
//定义子类
//1、类只支持单继承，不允许多继承，一个类只能有一个直接父类
//2、多个类可以继承一个父类
/*
* class A{}
* class B extends A{}
* class C extends A{}
* */
//3、可以多层继承类，即一个类的父类可以作为子类再去继承另一个父类
//   子类和父类是相对概念，如下：B是A的子类，是C的父类
/*
* class A {}
* class B extends A{}
* class C extends B{}
* */
//定义子类
class Subclass extends Animal{
    //定义打印动物名字的方法
    void printname(){
        System.out.println("name="+name);
    }
}
public class MyDemo4_1 {
    public static void main(String[] args) {
        Subclass subclass = new Subclass();
        subclass.name="旺财";
        subclass.printname();
        subclass.Shout();
    }
}
运行结果：
name=旺财
动物发出的叫声

Process finished with exit code 0

4、继承的注意事项

继承的注意事项
	a:子类只能继承父类所有非私有的成员(成员方法和成员变量)；
	b:子类不能继承父类的构造方法，但是可以通过super关键字去访问父类构造方法；
	c:不要为了部分功能而去继承

5、super关键字

概述：super代表的是父类存储空间的标识(可以理解成父类的引用,可以操作父类的成员)
使用格式：
	a:调用成员变量
		super.成员变量 	//调用父类的成员变量
	b:调用构造方法
		super(...)		//调用父类的构造方法
	c:调用成员方法
		super.成员方法 	//调用父类的成员方法

6、继承中构造方法的关系

	子类中所有的构造方法默认都会访问父类中的空参构造方法，因为子类会继承父类中的数据，还可能要使用父类的数据，所以在子类初始化之前，一定会先完成父类数据的初始化。

举例：

public class MyDemo4_1_3 {
    public static void main(String[] args) {
        //super关键字
        //1、使用super关键字调用父类的成员变量和成员方法
        /* super.成员变量
        *  super.成员方法（参数1,参数2...）
        * */
        Dog1 dog1 = new Dog1();
        dog1.shout();
        dog1.printName();
        System.out.println("************************");
        //2、使用super关键字调用父类的构造方法
        //super(参数1、参数2...);
        new Dog1();
    }
}
class Animal1{
    String name="动物";
    //定义动物叫声方法
    void shout(){
        System.out.println("动物的叫声");
    }
    //定义Animal1有参构造方法
    public Animal1(String name){
        System.out.println("你是一只"+name);
    }
}
//定义Dog1类继承动物类
class Dog1 extends Animal1{
    String name="狗";
    //重写父类shout()方法
    void shout(){
        super.shout();  //调用父类成员方法
    }
    public Dog1(){
        //注意：通过super调用父类的构造方法的代码必须位于子类构造方法的第一行，且只能出现一次
        //如果子类构造方法不指定调用父类那个构造方法（即不写下面那行代码），则默认调用父类无参的构造方法
        //为防止程序出现编译错误，可以在子类中显示的调用父类已有的构造方法，也可以在父类中定义无参的构造方法
        super("哈士奇");   //调用父类有参构造方法
    }
    void printName(){
        System.out.println("name="+super.name);//调用父类成员变量
    }
}
运行结果：
你是一只哈士奇
动物的叫声
name=动物
************************
你是一只哈士奇

Process finished with exit code 0

7、方法重写概述及应用

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

举例：

//定义Animal2类
class Animal2{
    void shout(){
        System.out.println("动物的叫声");
    }
}
//定义Dog类继承动物类
class Dog extends Animal2{
    //对父类方法重写，要求：要和父类被重写的方法具有相同的方法名、参数列表、返回值类型
    public void shout(){   //子类重写父类方法时，不能使用比父类中被重写方法更严格的访问权限
        System.out.println("汪汪汪");
    }
}
public class MyDemo4_1_2 {
    public static void main(String[] args) {
        new Dog().shout();
    }
}
运行结果：
汪汪汪

Process finished with exit code 0

注意事项：

方法重写注意事项
	a:父类中私有方法不能被重写，
		因为父类私有方法子类根本就无法继承；
	b:子类重写父类方法时，访问权限不能更低（最好一致）；
	c:父类静态方法，子类也必须通过静态方法进行重写

三、final关键字

1、final关键字的概述及特点

概述：final关键字是最终的意思，可以修饰类，变量，成员方法
final修饰特点：
	修饰类：被修饰的类不能被继承；
	修饰方法：被修饰的方法不能被重写；
	修饰变量：被修饰的变量（成员变量和局部变量）是常量，只能赋值一次，
			被修饰的成员变量，虚拟机不会对其进行初始化，
			被修饰的局部变量：
				基本类型，是值不能被改变；
				引用类型，是地址值不能被改变。

2、举例：

final class Fu{}
// class zi extends Fu{}    //错误！被final修饰的类不能被继承
class Fu1{
    public final void show(){
        System.out.println("被final修饰的方法");
    }
}
class Zi extends Fu1{
    //错误！被final修饰的方法不能重写
   /* public final void show(){
        System.out.println("重写方法");
    }*/
}
public class Example01 {
    public static void main(String[] args) {
        final int NUM=3;    //自定义常量 ，常量的命名规范 字母全部大写
        //NUM=10;  //错误，不能重新赋值
        Zi zi = new Zi();
        Zi zi1 = new Zi();
        final Zi dz=zi;
        //dz=zi1;   //错误！被final修饰的引用类型变量，不能重新赋新地址值
    }
}