Java基础知识（十三）（面向对象--4）

1、 方法重写的注意事项：
      (1)父类中私有的方法不能被重写
      (2)子类重写父类的方法时候，访问权限不能更低
           要么子类重写的方法访问权限比父类的访问权限要高或者一样
           建议：以后子类重写父类的方法的时候，权限修饰符写一样就不会发生这样的问题。
     (3)父类中静态的方法不能被重写，也就是说不能被Override修饰，因为静态的是属于类本身的           东西。

class OldPhone {
    private String name;

    public void call(String name) {
        System.out.println("打电话给" + name);
    }
    public static void play(){
        System.out.println("玩俄罗斯方块");
    }
}

class NewPhone extends OldPhone {
    @Override
    public void call(String name) {
//        super.call(name);
        System.out.println("看抖音");
    }

//    @Override
    public static void play(){
        System.out.println("玩王者荣耀");
    }

}


public class ExtendsDemo1 {
    public static void main(String[] args) {
        NewPhone newPhone = new NewPhone();
        newPhone.call("阿杰");
    }
}

2、父类的静态成员

class A{
    //将父类中的静态成员看作一个全局共享的，被所有的子类共享
    public static int a = 10;

    public static void fun(){
        System.out.println("hello");
    }
}

class B extends A{
    public void fun2(){
        a = 200;
        System.out.println(a);
    }

    public static void fun(){
        System.out.println("world");
    }
}


public class ExtendsDemo2 {
    public static void main(String[] args) {
        B b = new B();
        System.out.println(b.a);
        b.fun();
        b.fun2();
        System.out.println(b.a);
        System.out.println(A.a);

    }
}

  3、有些时候，我们不想让子类覆盖重写父类中的方法或者功能，只能让子类去使用。
        那怎么办呢？
        针对这个情况，java提供了一个关键字：final

        final:最终的意思。可以修饰类，成员变量，成员方法。

class Fu{
    public final void show(){
        System.out.println("这是父类中的show方法");
    }
}

class Zi extends Fu{
//    @Override
//    public void show(){
//        System.out.println("这是子类中的show方法");
//    }

}

public class ZiDemo {
    public static void main(String[] args) {
        Zi zi = new Zi();
        zi.show();
    }
}

4、 final的特点：
       (1)修饰类，类不能被继承
       (2)修饰成员变量，变量变常量，并且只能赋值一次,在构造方法完毕之前赋值即可。
                常量：
                    字面值常量
                    自定义常量：被final修饰变量变成自定义常量
       (3)final修饰成员方法：方法不能被重写

//无法从最终com.shujia.wyh.day11.Fu2进行继承
//final class Fu2{}

class Fu2{
    int num = 10;

//    final int num2 = 200;
    final int num2;
//    {
//        num2 = 400;
//    }

    Fu2(){
        num2 = 400;
    }

}

class Zi2 extends Fu2{
    public void show(){
        num = 100;
        System.out.println(num);
//        num2 = 300; //无法为最终变量num2分配值
        System.out.println(num2);
    }
}

public class FinalDemo {
    public static void main(String[] args) {
        Zi2 zi2 = new Zi2();
        zi2.show();

    }
}

5、面试题：
            final修饰局部变量

           (1)在方法内部，修饰基本数据类型的变量，变量值只能赋值一次，不能发生改变
           (2)final修饰引用数据类型的变量呢？
              引用的地址值不可以发生改变你，但是该对象的堆内存中的值是可以发生改变的。

class Student {
    int age = 10;
}
public class FinalDemo2 {
    public static void main(String[] args) {
        int x=100;
        x=300;
        System.out.println(x);

        final int y = 200;
//        y = 400; //无法为最终变量y分配值
        System.out.println(y);
        Student student = new Student();
        System.out.println(student.age);

        final Student s2 = new Student();
        System.out.println(s2.age);

        s2.age = 1000;
        System.out.println(s2.age);
        System.out.println("==========================");
//        s2 = new Student(); //无法为最终变量s2分配值
    }
}