Java中的方法重写~多态~static关键字的使用

方法的重写

• 重写：都是方法的重写，和属性无关。
• 必须建立在extends(继承)关系上，子类重写父类的方法。
  • 方法名必须相同
  • 参数列表必须相同
• 子类的方法必须和父类的必须要一直，方法体不同！

代码实现
为什么要重写方法？
因为父类的功能子类不一定需要，或者不一定满足！

    package com.oop5;
    /*
        父类
     */
    public class A {
        public void test1(){
            System.out.println("A类！");
        }
    }
    package com.oop5;
    /*
        子类，继承父类
     */
    public class B extends A{
        @Override
        public void test1() {
            System.out.println("B类");
        }
    }
    package com.oop5;
    /*
        重写测试类
     */
    public class Test {
        public static void main(String[] args) {
            B b = new B();
            b.test1();
            A a = new B();
            a.test1();  // 子类重写父类方法之后，数据类型就不会指向B
        }
    }
    输出：
        B类
        B类

多态

• 即同一方法可以根据发送对象的不同而采取用多种不同的行为方式。
• 一个对象的实际类型是确定的，但可以指向对象引用的类型有很多。
• 多态存在的条件
  • 有继承关系
  • 子类重写父类的方法
  • 父类引用指向子类对象
• 注意：多态是方法的多态，属性是没有多态性的。
• instanceof
• 只要子类没有重写父类，子类就调用父类的方法；
• 如果子类重写了父类的方法，它就会调用子类的方法。

代码实现：

    package com.oop6;
    /*
        父类
     */
    public class Person {
        public void sleep(){
            System.out.println("父类");
        }
    
    }
    package com.oop6;
    
    public class Student extends Person{
       // 子类重写父类方法
        @Override
        public void sleep() {
            super.sleep();
        }
        public void eat(){
            System.out.println("父类中的方法：吃");
        }
    }
    
    package com.oop6;
    /*
        多态测试类
     */
    public class Application {
        public static void main(String[] args) {
            // Student 能调用的方法都是自己的或者继承父类的
            Student s1 = new Student();// 使用子类引用指向子类对象
            // Person 父类型，可以指向子类，但是不能调用子类的独有方法
            Person s2 = new Student();  // 对象能执行那些方法看左边 // 使用父类引用指向子类对象
            // 使用祖父类引用指向子类对象
            Object s3 = new Student();
            s1.sleep();   // 子类重写了父类的方法，执行了父类的方法
            s1.eat();
    //        s2.eat();  // 父类不能调用子类中独有的方法
        }
    }
    
    输出：
           父类
           父类
           父类中的方法：吃
           父类中的方法：吃

多态注意事项：

• 1、多态是方法的多态

• 2、父类和子类，有联系 类型转换异常(ClassCastException)

• 3、存在条件：继承关系，方法需要重写；父类的引用指向的是子类对象! A a = new B();

  • 4、static 方法，属于类，不属于实例
  • 5、final 常量，被它修饰的变量在程序运行时不会改变值；方法不能被重写；类不能被继承…等
  • 6、private：私有化，修饰的方法不能被重写。

• instanceof：关键字，就是验证两个类是否是父子关系；两个类要是有关系就会返回true否则返回false

X instanceof Y：这个代码编译是否能通过

向上转型

• 向上转型：把子类转换为父类

向下转型

• 向下转型：把父类转换为子类，需要强制类型转换。

如：Person(人类) Student(学生类)，把人类转换为学生类的时候自动转换。
Student中有一个方法eat();

// 父类的引用指向子类的对象 称为：向上转型
Person person = Student stdent();
// 父类调用子类中的eat方法，就需要强制转换，因为是高类型--->低类型。称为：向下转型
((Student)person).eat();

代码实现：

    package com.oop7;
    // 父类
    public class Three {
        
    }
    
    package com.oop7;
    // 子类
    public class One extends Three {
        public void sleep(){
            System.out.println("冰冻三尺非一日之寒！");
        }
    }
    
    package com.oop7;
    // 子类
    public class Two extends Three {
        public void print(){
            System.out.println("我是子类中方法哦!");
        }
    }
    
    package com.oop7;
    public class Test {
        public static void main(String[] args) {
            Object object = new Three();
            System.out.println(object instanceof Three);
            System.out.println(object instanceof Two);
            // 高          低
            // 低-->高是自动类型转换 相反是强制类型转换
            Three t = new One();
            // 强制类型转换 把需要转换的类型加个括号写在变量前面就行
            ((One)t).sleep();
            Three t1 = new Two();
            ((Two) t1).print();
        }
    }
    
    输出：
    	true
    	false
    	冰冻三尺非一日之寒！
    	我是子类中方法哦!

static关键字

static：静态的，它是跟类一块加载的；在同一个类中被static修饰的属性或者方发可以直接使用类名调用。

    package com.oop8;
    
    import com.oop5.Test;
    
    public class TestStatic {
        private static String name;
        {
            this.name = "张三";  // 第二执行：使用匿名代码块进行赋初始值
            System.out.println("匿名代码块~");
        }
        // 最先执行：因为跟类一块加载，只执行一次
        static {
            System.out.println("静态代码块~");
        }
        // 最后执行：使用new创建对象时会默认执行
        public TestStatic() {
            System.out.println("构造器~");
        }
    
        public static void main(String[] args) {
            TestStatic testStatic = new TestStatic();
            System.out.println(testStatic.name);
            System.out.println("=============================");
            TestStatic testStatic1 = new TestStatic();
        }
    }
    输出：
          静态代码块~
          匿名代码块~
          构造器~
          张三
          =============================
          匿名代码块~
          构造器~

• 静态导入包

• 静态导入

    package com.oop8;
    // 静态导入包
    import static java.lang.Math.*;
    
    public class Test {
        public static void main(String[] args) {
            // random 是Math类中的一个随机数方法
            System.out.println(random());
            System.out.println(PI);
        }
    }
    输出：
    	0.6448610144307986
    	3.141592653589793

在Java中可以使用静态导入包，方便使用方法。