instance和类型转换

#多态#

即同一方法可以根据发送对象的不同而采用多种不同的行为方式。

一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多(父类，有关系的类)

多态存在的条件 有继承关系

子类重写父类方法

父类引用指向子类对象

 

注意:多态是方法的多态，属性没有多态性。

instanceof (类型转换) 引用类型

 package com.oop.demo06;
 ​
 public class Person {
     public void run(){
         System.out.println("run");
     }
 }
 /*
         //Object-->String
         //Object-->Person-->Teacher
         //Object-->Person-->Student
         Object object = new Student();
 ​
         //System.out.println(X instanceof Y);//能不能编译通过!
 ​
         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);//编译就报错!!Person与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);//编译就报错!
  */
 ​

 package com.oop;
 ​
 ​
 import com.oop.demo06.Person;
 import com.oop.demo06.Student;
 ​
 //一个项目应该只存在一个main方法
 public class Application {
     public static void main(String[] args){
         //类型之间的转化： 基本类型转换  高低64 32 16 8 高到低：强转
         //类型之间的转化：父  子
 ​
         //高                    低
         Person person = new Student();
         //person.eat();//报错： 父类用不了子类的方法 需强制转换
         Student student = (Student)person;
         student.eat();//吃吃吃，就知道吃！
 ​
         System.out.println("=====================");
         //子类转父类可能会丢失一些本来的方法
         Student s = new Student();
         s.eat();
         Person person1 = s;
     }
 }
 /*
     1.父类引用指向子类的对象
     2．把子类转换为父类,向上转型;
     3．把父类转换为子类,向下转型;强制转换
     4.方便方法的调用，减少重复的代码!简介
 ​
     封装、继承、多态!   抽象类，接口
 ​
  */

面向对象三大特性：强调一下

封装 继承 多态

抽象： 编程思想！ 持续的学习，茅塞顿开！多实践，多测试大脑中的想法！实践出真知

static关键字详解

 package com.oop.demo07;
 ​
 //Static
 public class Student {
 ​
     private static int age;//静态的变量
     private double score;//非静态变量
 ​
     public void run(){
         System.out.println("小狗在叫");
     }
 ​
     public static void go(){
         System.out.println("它跑起来了");
     }
 ​
     public static void main(String[] args) {
         go();//静态调静态
         new Student().run();//调普通方法（非静态方法）
     }
 }

 package com.oop.demo07;
 ​
 public class Person {
 ​
     /*{
         //代码块（匿名代码块）
     }
 ​
     static {
         //静态代码块
     }*/
     //2:赋初始值~
     {
         System.out.println("匿名代码块");
     }
     //1:静态代码块只执行一次~
     static{
         System.out.println("静态代码块");
     }
     //3.
     public Person() {
         System.out.println("构造方法");
     }
 ​
     public static void main(String[] args) {
         Person person1 = new Person();
         System.out.println("==================");
         Person person2 = new Person();
     }
 }

 package com.oop.demo07;
 ​
 //静态导入包~
 import static java.lang.Math.random;
 import static java.lang.Math.PI;
 ​
 ​
 public class Test {
 ​
     //Math.random() : 随机数
     public static void main(String[] args) {
         //System.out.println(Math.random());
         System.out.println(random());
         System.out.println(PI);
     }
 }