【Java基础】Java面向对象之 static、instanceof 关键字详解

Java面向对象之 static 关键字

static 关键字详解

  1. java static 关键字:

    静态方法在当前类中可直接进行调用或者通过“类名.方法名”调用

    非静态方法需要实例化对象进行调用

    非静态方法可以调用静态方法

  2. 实例:
    package oop.demo11;
    
    /**
     * static关键字详解
     * 静态方法在当前类中可直接进行调用或者通过“类名.方法名”调用
     * 非静态方法需要实例化对象进行调用
     * 非静态方法可以调用静态方法
     */
    public class Student {
          
          
    
        private static int age; //静态变量
        private double score; //非静态变量
    
        public void run(){
          
          
            go(); //非静态方法可以调用静态方法
        }
    
        public static void go(){
          
          
            System.out.println("go");
        }
    
        public static void main(String[] args) {
          
          
    
            Student student = new Student();
    
            System.out.println(Student.age);
            System.out.println(student.age);
            System.out.println(student.score);
    
            student.run(); //非静态方法需要实例化对象进行调用
            go(); //静态方法在当前类中可直接进行调用或者通过“类名.方法名”调用,如Student.go();
        }
    
    }
    

静态导入包

  1. 静态导入包

    import static java.lang.Math.random;
    import static java.lang.Math.PI;
    静态导入包可省略Math,可直接调用方法:
       System.out.println(random());
       System.out.println(PI);
       否则:
       System.out.println(Math.random());
       System.out.println(Math.PI);
    
  2. 实例:
    package oop.demo11;
    
    /**
     * 静态导入包
     * import static java.lang.Math.random;
     * import static java.lang.Math.PI;
     * 静态导入包可省略Math,可直接调用方法:
     *    System.out.println(random());
     *    System.out.println(PI);
     *    否则:
     *       System.out.println(Math.random());
     *       System.out.println(Math.PI);
     */
    
    import static java.lang.Math.random;
    import static java.lang.Math.PI;
    
    public class Test {
          
          
    
        public static void main(String[] args) {
          
          
    
            //随机数Math.random: System.out.println(Math.random());
            System.out.println(random()); //静态导入包可省略Math,可直接调用方法
    
            //π:3.141592653589793
            System.out.println(PI); //静态导入包可省略Math,可直接调用方法
        }
    
    }
    

类中方法执行顺序

  1. 类中方法执行顺序

    1、静态代码块:类加载就执行,永久只执行一次,方便加载一些初始化的东西

    2、匿名代码块:赋初始值~

    3、构造器

  2. 实例:
    package oop.demo11;
    
    /**
     * 类中方法执行顺序
     * 1.静态代码块:类加载就执行,永久只执行一次,方便加载一些初始化的东西
     * 2.匿名代码块:赋初始值~
     * 3.构造器
     */
    public class Person {
          
          
    
        {
          
          
            //2.匿名代码块:赋初始值~
            System.out.println("匿名代码块");
        }
    
        static {
          
          
            //1.静态代码块:类加载就执行,永久只执行一次,方便加载一些初始化的东西
            System.out.println("静态代码块");
        }
    
        //3.构造器
        public Person() {
          
          
            System.out.println("构造方法");
        }
    
        //执行顺序:1.静态代码块(只执行一次) 2.匿名代码块 3.构造方法
        public static void main(String[] args) {
          
          
            Person person1 = new Person();
            System.out.println("-------------- 分隔符 ---------------");
            Person person2 = new Person();
        }
    
    }
    

Java面向对象之 instanceof 关键字

入口

  1. java面向对象三大特性:

    封装:

    将类的某些信息隐藏在类内部,不允许外部程序直接访问,而是通过该类提供的方法来实现对隐藏信息的操作和访问。

    继承:

    继承是类与类的一种关系,是一种“is a”的关系。比如“狗”继承“动物”,这里动物类是狗类的父类或者基类,狗类是动物类的子类或者派生类。

    多态:

    同一个引用类型,使用不同的实例,执行不同的操作。方法重写是实现多态的基础。

  2. java instanceof 关键字:

    instanceof 关键字判断一个对象是什么类型

    System.out.println(X instanceof Y); //能不能编译通过取决于X和Y之间有没有父子关系

  3. 注意:

    1、父类引用指向子类的对象

    2、把子类转换为父类,向上转型

    3、把父类转换为子类,向下转型(强制转换)

    4、强制转换为了方便方法的调用,减少重复的代码,简洁

    抽象(编程思想):封装、继承、多态

  4. 实例:
    package oop.demo10;
    
    /**
     * instanceof关键字判断一个对象是什么类型
     * System.out.println(X instanceof Y); //能不能编译通过取决于X和Y之间有没有父子关系
     * 注意:
     * 1.父类引用指向子类的对象
     * 2.把子类转换为父类,向上转型
     * 3.把父类转换为子类,向下转型(强制转换)
     * 4.强制转换为了方便方法的调用,减少重复的代码,简洁
     * 抽象(编程思想):封装、继承、多态
     */
    public class Application {
          
          
    
        public static void main(String[] args) {
          
          
    
            /**
             * Object > Person > Student
             * Object > Person > Teacher
             * Object > String
             */
            Object object = new Student();
    
            System.out.println(object instanceof Student); //true
            System.out.println(object instanceof Person); //true
            System.out.println(object instanceof Object); //true
            System.out.println(object instanceof Teacher); //false
            System.out.println(object instanceof String); //false
    
            System.out.println("------------------ 分隔符 ----------------");
    
            Person person = new Student();
            System.out.println(person instanceof Student); //true
            System.out.println(person instanceof Person); //true
            System.out.println(person instanceof Object); //true
            System.out.println(person instanceof Teacher); //false
            // System.out.println(person instanceof String); //编译报错
    
            System.out.println("------------------ 分隔符 ----------------");
    
            Student student = new Student();
            System.out.println(student instanceof Student); //true
            System.out.println(student instanceof Person); //true
            System.out.println(student instanceof Object); //true
            //System.out.println(student instanceof Teacher); //编译报错
            //System.out.println(student instanceof String); //编译报错
    
            System.out.println("------------------ 类型转换 ----------------");
            /**
             * 类型之间的转换:父  子
             */
            //Person 高 ---> Student低
            Person obj = new Student();
            Student student1 = (Student) obj; //高转低 强转 将Person类型转换为Student类型
            student1.go(); //转换类型后才可调用Student类中的go方法  合并:((Student) obj).go();
    
            //子类转换为父类,可能丢失自己本来的一些方法
            Student student2 = new Student();
            student2.go();
            Person person1 = student2; //Student类型转换为Person类型
            person1.run(); //子类转换为父类无法再调用子类本身的go方法,可以调用父类的run方法
    
        }
    }
    

Person类

  • package oop.demo10;
    
    public class Person {
          
          
    
        public void run(){
          
          
            System.out.println("run");
        }
    }
    

Student 类继承 Person 类

  • package oop.demo10;
    
    public class Student extends Person {
          
          
    
        public void go(){
          
          
            System.out.println("go");
        }
    }
    

Teacher 类继承 Person 类

  • package oop.demo10;
    
    public class Teacher extends Person {
          
          
    
        public void teach(){
          
          
            System.out.println("teach");
        }
    }
    

猜你喜欢

转载自blog.csdn.net/weixin_54707168/article/details/114153114