Article Directory
Java object-oriented static keyword
Detailed explanation of static keyword
-
java static keywords:
Static methods can be called directly in the current class or through "class name. method name"
Non-static methods need to instantiate the object to call
Non-static methods can call static methods
-
Examples:
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(); } }
Static import package
-
Static import package
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); -
Examples:
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,可直接调用方法 } }
Method execution order in the class
-
Method execution order in the class
1. Static code block: execute when the class is loaded, and only execute once forever, which is convenient for loading some initialization things
2. Anonymous code block: assign initial value~
3. Constructor
-
Examples:
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 object-oriented instanceof keyword
Entrance
-
Three major object-oriented features of java:
Package:
Certain information such hidden inside the class, does not allow direct access to external programs, but to achieve the operations and access to hidden information provided by the methods of the class.
inherit:
Inheritance is a relationship class and class, is a "is a" relationship. For example, "dog" inherits "animal", where the animal class is the parent or base class of the dog class, and the dog class is the subclass or derived class of the animal class.
Polymorphism:
The same reference type, different instance, to perform different operations. Method rewriting is the basis for achieving polymorphism.
-
java instanceof keywords:
The instanceof keyword determines what type an object is
System.out.println(X instanceof Y); //Can compile and pass depends on whether there is a parent-child relationship between X and Y
-
note:
1. The parent class refers to the object of the subclass
2. Convert the sub-category to the parent category and upward transformation
3. Convert the parent class to the subclass, and downcast (forcible conversion)
4. Forcing conversion to facilitate method calls, reduce repetitive code, and be concise
Abstraction (programming ideas): encapsulation, inheritance, polymorphism
-
Examples:
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 class
-
package oop.demo10; public class Person { public void run(){ System.out.println("run"); } }
The Student class inherits the Person class
-
package oop.demo10; public class Student extends Person { public void go(){ System.out.println("go"); } }
The Teacher class inherits the Person class
-
package oop.demo10; public class Teacher extends Person { public void teach(){ System.out.println("teach"); } }