java面向对象的特征-继承，重载和重写，final关键字

继承

概念：

• 继承就是子类继承父类的特征和行为，使得子类具有父类的实例域和子类具有父类的相同行为
• java中类的继承是单继承
• 父类不能调用子类的方法

1、重载

概念：发生在同一类中，方法名相同，参数列表不同的方法，叫重载

首先得满足精确性，先找到符合的，不行再自动自动增加，子类转父类是自动转换。

2、重写

概念：

• 发生在父子类之间，子类继承父类，把方法签名相同的方法再定义一遍，重写的意义在于从子类的角度提供高继承的灵活度，

• 父类方法访问权限修饰符为private则子类就不能继承过来，也就不能重写该方法了，意义也是在于从父类的角度提高出承的灵活度

**注意：**对于父亲的private的方法，孩子是不能够继承的，不能够重写，将不能使用父亲的私有的方法

 //不能够继承，只是父亲的,则子类就不能继承过来，也就不能重写该方法了
    private void sleep(){
        System.out.println("任何人都会睡觉");
    }

3、super

• 调用父类的方法
• 调用父类的构造方法

package com.oop;

public class Person2 {

    public String from;

    public Person2(){
        System.out.println("父类的无参构造");
    }

    public Person2(String from){
        System.out.println("父类的有参构造");
        this.from=from;
    }

    public void run(){
        System.out.println("任何人都可以跑！");
    }
    public void eat(){
        System.out.println("任何人都会吃");
    }

    //不能够继承，只是父亲的
    private void sleep(){
        System.out.println("任何人都会睡觉");
    }
}


//----------------------------------------------------------------------------------------
package com.oop;

public class Student1 extends Person2 {

    public String name;
    public int age;

    public Student1(){
        super("中国");  //先把父类的构造方法初始化，再调用子类的构造方法
        System.out.println("子类的无参构造方法");
    }

    @Override  //方法重写
    public void eat(){
        System.out.println("学生正在吃！");
    }
    @Override
    public void run(){
        super.run();   //父亲的方法不太完善，先把父亲的方法调一下
        this.eat();    //this可以省略，指的是本类的方法
        System.out.println("学生会跑的很快");
    }

    public static void main(String[] args) {
        Student1 st=new Student1();
        st.run();
        st.eat();
        System.out.println(st.from);

    }
}

输出顺序：
1、父类静态资源
2、子类静态资源
3、父类非静态
4、子类非静态
注意：子类构造器中如果不写supper（）方法，将会自动的默认调用父类的无参构造

4、继承层次

**概念：**java类只支持单继承，不支持多继承，但是可以支持多级（多层继承），从某个特定类到其祖先的路径称为继承链，在继承链中，如果直系代没有重写方法，可以隔代重写方法，否则不可隔代重写方法，而是重写的直系代的方法

---

注意：我继承父亲继承爷爷，隔代可以重写，但是例如：

• ​ 如果父亲没有头重写爷爷的run()方法，则能重写爷爷的run()方法，，

• ​ 如果父亲重写了爷爷的run()方法，则我不能重写爷爷的run()方法，只能重写父亲的run()方法

执行顺序：

输出：先执行父类，再子类，如果反过来就被父类覆盖了，子类的初始化不起作用

//输出
base static
test static
base constructor 父类构造方法
test constructor 子类构造方法

练习：当执行main函数时，会加载本类的静态变量，此时 String name和 MyPerson person=new MyPerson(“text”);都不是static修饰的，以至于它此时没有空间，则不会调用，当对象一经创建时，才可以调用它，就会执行。

public class MyTest {
    String name="张三";    //没有satic修饰，类加载时没有内存空间
    MyPerson person=new MyPerson("text");  //没有satic修饰，类加载时没有内存空间

    static {
        System.out.println("test static");
    }

    public static void main(String[] args) {

    }
}

5、final（固定的是一个地址）

1. 变量

   • 基本类型：不可变

   • 引用类型：可变

   • 如图：基本变量，不可改，引用变量例如arr[0]=45,可改变
     

   • 局部常量：可以不用赋值，但是在使用之前必须赋初始值（且只能赋值一次）

   • 全局变量：一定要赋值

2. 方法：final修饰的方法将不能被重写
3. 类：如果加上public final class Test3 {}，则这个类将不会被继承
4. final可以防止指令重排序，保证线程安全（保证代码的顺序执行）
   • 指令重排序：是jvm性能优化过程，目的是提高整个代码执行的效率和性能
   • 单线程：可以调优（可以调整代码的执行顺序，但是能保证每一段代码都执行了）
   • 多线程时：（如果调优比较乱，最终可能导致有些代码最终没有执行，所以可以设置final防止指令重排序，顺序的执行代码，保证了线程的安全）