JavaSe基础2022年12月09日学习内容

JavaSe-2022-12-09面向对象

每日一句: 不能既配不上自己的野心，又辜负了自己曾经受的苦。

学习内容：final关键字、向下转型、多态、抽象类

• final关键字最终的

  • 修饰变量，变量一旦赋值则不能修改

  • 修饰方法，不能被子类重写，但是可以被继承

  • 修饰类，该类不能被继承

  • 代码的实现

    public class TestFinal {
        public static void main(String[] args) {
            final int i;//局部变量
            i =100;
            System.out.println(i);
            //i = 200; 再次分配就是错的 只能赋值一次 或者是写成默认值
            final int[] arr = {1,2,3};//引用的对象不能改变
            arr[0] = 100;//正确
            //arr =  new int[10]; 报错
            Aoo t = new Aoo();
            t.f();
        }
    }
    class Too{
        //final修饰的成员变量需要直接赋值，通常用来定义常量
        public final int x = 10;
        public void print(){
            //System.out.println(x++); //报错
        }
        public final void f(){
            System.out.println("f方法");
        }
    }
    
    final class Aoo extends Too{
        //public void f(){} 不能重写父类中使用final修饰的方法
    }
    
    //class Coo extends Aoo{} //不能继承Final修饰的类
    

• 向下造型

  • 向下造型的前提是我们要先向上造型，向上造型就是父类的引用指向子类的对象

  • 向下造型，就是将父类的引用强制转换成子类的引用，我们就可以通过子类去调用子类特有的方法

    //创建一个父类
    class Father{
        public void f(){
            System.out.println("father F");
        }
    }
    //创建两个子类继承父类
    class Child extends Father{
        public void f(){
            System.out.println("child F");
        }
        public void f2(){
            System.out.println("child F2");
        }
    }
    class Child02 extends Father{
        public void f(){
            System.out.println("child F");
        }
        public void f3(){
            System.out.println("child F3");
        }
    }
    
     public static void main(String[] args) {
            Father f=  new Child();
    //        f.f();
    //        如何调用子类特有的方法呢？使用向下转型
           // child02 cc  = (child02)f; 报错 可以使用向下转型前判断父类引用的类型
            //instanceof:判断前者引用的实列对象是否是后者的类型
            if(f instanceof  Child){
                Child cc = (Child) f; //先判断再向下转型
                cc.f2();
            }
            if(f instanceof Child02){
                Child02 cc = (Child02) f;
                cc.f3();
            }
     }
    

• 多态

  • 多态的概念：通俗来说就是多种形态，具体点就是去完成某个行为，当不同的对象去完成所产生出不同的状态。

  • 多态有两种实现方式

    • 使用父类作为方法的形参

    • 使用父类作为方法的返回值

    • public class TestFlyingObject {
          public static void main(String[] args) {
      		//使用父类进行接受
              TestFlyingObject f = createFlying();
              System.out.println(f);
          }
          //使用父类作为返回值类型
          public static TestFlyingObject createFlying(){
              Random random = new Random();
              int n = random.nextInt(2);
              TestFlyingObject f = null;
              if (n == 0){
                  f = new AirPlane();
              }else if(n == 1){
                  f = new BigPlane();
              }
              return f;
          }
      }
      
      class BigPlane extends TestFlyingObject {
          public void move(){
              System.out.println("大敌机在移动...");
          }
      }
      class AirPlane  extends TestFlyingObject {
          public void move(){
              System.out.println("小敌机在移动...");
          }
      }
      

• 抽象类

  • 关键字abstract

  • 什么是抽象类：含有抽象方法（但不一定存在）抽象类不能实例化，一般用做模板类，给子类继承，还可以使用抽象方法强制子类重写

  • 有抽象方法的类一定是抽象类

    • public abstract class AbstractTest {
          public static void main(String[] args) {
          }
          public abstract void t();
      
      }
      class Animal extends AbstractTest{
          //必须要重写抽象类中的方法
          @Override
          public void t() {
              System.out.println("重写了抽象类中的t()方法");
          }
      }
      abstract class Animal2 extends AbstractTest{
          //不用重写抽象类中的方法
      }
      

    • gitee代码仓库地址:https://gitee.com/Zhengsenbing/java-se-basic