day 9：Java语言中的继承和多态

小回顾：

一个类的成员变量new完了会被初始化几次：

1、jvm的默认初始化

2、显式的赋值初始化

3、构造方法的初始化

final:

1、final修饰的变量变成常量。不能修改；自定义常量其实质是final修饰的变量；

int i;（变量）

final int i;（自定义常量）

2、被final修饰的类不能被继承，被final修饰的方法不能被覆盖；

初始化自定义常量值的时机：

1、在声明变量的时候给初始值

2、在构造方法中赋初值

package bamzhy.extend;

public class Demo1 {
    //一旦在构造方法中来对自定义常量初始化：
    //1、就必须保证构造方法中的代码一定会对自定义常量进行初始化
    //2、必须保证每一个构造方法中都有对自定义常量的初始化操作
    final int j;
    public Demo1(){
        j=100;//构造方法中初始化定义自定义常量的初值
    }
    public Demo1(int j){
        this.j=j;
    }

    public static void main(String[] args) {
        final int i=0;


//        i=1;不能改变final修饰的变量的值
        //我们常用的string，定义是public final class String,由于其中有final所有不能够被继承
        //class ab extends String 非法
    }

}

当没有package关键字的时候，当我们用文本编辑器写代码、执行的时候虽然也没有问题，但是所有没有在java源文件只用package指定所属包的情况下，这些类都属于默认包；

package<包名>；package bamzhy.extend

包的作用：

1、将相关的类和接口分组，包名通常表示包中各个类和接口的用途（方便维护代码）

2、包创建了不同的命名空间（namespace），从而有效地解决了类型命名的冲突问题（同名类）

bamzhy.extend     bamzhy.enxtend,java

3、包提供了对应用程序内部实现机制的保护域（default，protected）default跨包不能访问；protected跨包非子类不能访问

import：当在本java文件中，使用非本java文件所在包中的类时，虚拟机或编译器默认是不会去其他包中搜索该类，import就是告诉编译器或java虚拟机，某非本报的类的位置，java虚拟机或者编译器在需要用到该类的时候可以去import指明的位置搜索。

在类名前面加上类所属的包名，中间用.分隔，称之为类的完全限定名（full Qualified Name），简称类的限定名

import声明一般紧跟在package声明之后，必须在类声明之前 import<bamzhy.extend.java.demo1>

java语言核心包 java.lang包中的类将被隐式的导入，可以直接使用其中的类；

import声明提供了一种包的智能导入方式：import<包名>.*  这样可以把*下的所有类都导入，值得注意的是：import *不能把*下的其他包中的类也导入（不能递归导入）

package bamzhy.extend;

import java.io.PrintStream;
import  bamzhy.method.Student;

public class Demo2 {
    public static PrintStream out=null;
    final static int j;
    static {
        j=10;
    }
    //不能再构造方法中对它进行初始化，静态成员变量随类加载而加载到=内存中，即在类加载完成后，我们就可
    // 以通过类名来访问到静态的自定义常量j
    public Demo2(int j){
        j=1;
    }

    public static void main(String[] args) {
        //默认情况下，java编译器只会在当前包下搜索类，一旦搜索不到就认定该类没有被定义
        //1、使用全类名，就类似于我们文件系统中定位文件的绝对路径；
        bamzhy.method.Student st=new bamzhy.method.Student();
        //2、使用import：import  bamzhy.method.Student;
        Student st1=new Student();
        //import不能递归导入
        //如果本类中，有和被引入的静态成员（静态成员方法相同的成员变量，此时jvm只会使用本类中的成员变量
//        out.println("hello import static");
    }
}

package bamzhy.extend;

/*概述：某一个事物（相同函数名），在不同时空表现出来的不同形态（不同函数体）
 多态的前提：
 1、要有继承关系：（运行时多态发生范围）
 2、要有方法覆盖
 3、要有父类引用指向子类对象（子类实例）

 方法覆盖：
    是指在子类中替换父类或祖先类对某个方法的实现（子类中有方法与相应父类中的方法相同
    方法覆盖通过子类重新定义与父类或祖先类具有同样签名和返回类型的方法实现；
    同样的签名+同样的返回值类型
    覆盖的方法可以保持和父类的方法相同的可访问范围，也可以修改访问控制修饰符增大可访问范围，但是不能减小可访问范围
    被final修饰的方法不允许在子类中覆盖
    父类被覆盖的方法的参数列表中被声明为final的参数，在子类的覆盖方法中可以不必指定为final
    只有在子类类体中可以访问的父类或祖先类的方法才能被覆盖
    静态方法不能被覆盖，只能被隐藏
 */
//
public class Demo3 {
    public static void main(String[] args) {
        Son son=new Son();
    }
}

class Father{
    public void  show(){
        System.out.println("father");
    }
    public void testFinal(final int a,final int b){}
    //用final修饰形参的意思是，仅仅咋方法体中不能修改形式参数的值，跟调用几次
//    a=1;
    private void testAcess(){

    }
    static void testStatic(){

    }
}


class Son extends Father{
//在子类中定义了和父类相同的方法
//override :让编译器帮助检测我们是否完成了覆盖动作

    @Override
    public void show() {
        System.out.println("Son");
    }
//    @Override
//    public void test() {
//        show();
//        super.show();
//    }
    @Override
    public void testFinal(int a,int b){
        
    }
//    @Override
//    public void testAccess(){
//        
//    }
//    @Override
//    static void testStatic(){
//        
//    }
}