Java instanceof 全小写 关键字使用

本文主要是介绍Java instanceof 全小写 关键字使用，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

  1 package com.bytezreo.duotai2;
  2 
  3 import java.sql.Date;
  4 
  5 /**
  6  * 
  7  * @Description    面向对象的特征三 ------多态性
  8  * @author  Bytezero·zhenglei!      Email:420498246@qq.com
  9  * @version
 10  * @date 2021年9月20日下午4:56:10
 11  * @
 12  * 
 13  * 
 14  * 1.理解多态性：  可以理解为一个事物的多态性 
 15  * 2.何为多态性：  父类的引用指向子类的对象（或子类的对象赋给父类的引用）
 16  *
 17  * 3.多态的使用：虚拟方法调用
 18  * 有了对象的多态性的以后，我们在编译器期，只能调用父类中声明的方法，但是
 19  * 在运行期，我们实际执行的是 子类重写父类的方法。
 20  * 
 21  *  总结：编译，看左边，执行看右边
 22  *  
 23  * 4.多态性的使用前提：(1)类的继承关系  (2) 要有方法的重写
 24  *
 25  * 5.对象的多态性，适用于方法，不适用于属性(属性：编译和运行都只看左边)
 26  *
 27  * 6.多态性是运行时行为;        
 28  * 
 29  * 7.动态绑定
 30  * 
 31  * 
 32  * ****************************************************************************
 33  * 
 34  * 
 35  * 
 36  */
 37 public class PersonTest 
 38 {
 39     public static void main(String[] args) 
 40     {
 41         Person p1 = new Person();
 42         p1.eat();
 43         
 44         
 45         Man man = new Man();
 46         man.eat();
 47         man.age = 25;
 48         man.makeMoney();
 49         
 50         /***********************/
 51         System.out.println("----------------------------");
 52         //对象多态性：父类的引用指向子类的对象
 53         Person p2 = new Man();
 54         
 55         //多态的使用：当调用子父类同名同参的方法时，实际执行的是子类重写父类的
 56     //方法---虚拟方法调用
 57         p2.eat();    //子类的
 58         p2.walk();
 59         
 60         
 61         //p2.makeMoney();
 62         
 63         
 64         
 65         
 66 //        Person p3 = new Woman();
 67         
 68         System.out.println(p2.id); //1001   父类
 69     //    ***********************************************
 70         
 71         
 72         System.out.println("************************");
 73         
 74         
 75         //不能调用子类所特有的方法,属性：编译时，p2是person类型，
 76 //        p2.makeMoney();
 77         
 78         //p2.isSmoking = true;
 79         p2.name = "Tom";
 80         
 81         //有了对象的多态性以后，内存中实际上是加载了子类特有的属性和方法，但是
 82 //由于变量声明为父类类型，导致编译时，只能调用父类中声明的属性和方法。子类特有的
 83 //属性和方法不能调用。
 84         
 85         //如何才能调用子类特有的属性和方法？
 86         //使用强制类型转换符 
 87         Man m1 =  (Man)p2; //强转类型
 88         m1.makeMoney();
 89         m1.isSmoking = true;
 90         
 91         
 92         //使用强转时，可能出现 .ClassCastException的异常
 93 //        Woman w1 = (Woman)p2;
 94 //        w1.goShopping();
 95         
 96         //为了避免 ClassCastException的异常 引入了
 97         // instanceof  全小写
 98         /**
 99          *  instanceof  全小写 关键字使用
100          *  
101          *  a  instanceof A : 判断 对象 a 是否是类A的实例
102          *  如果是 返回 true  不是返回 false
103          *  
104          *  
105          *  使用情境：为了避免向下转型时出现 ClassCastException的异常，我们在向下
106          *  转型进行之前，先进行 instancof 的判断，一旦返沪true,就进行向下转型，
107          *  如果 返回 false，不进行向下转型
108          *  
109          *  如果 a instanceof A 返回 true,则 a instanceof B 也返回true.
110          *  其中 类B是类A的父类。
111          *  
112          *  
113          */
114         
115         //执行不了   new 的是什么就是什么  Person p2 = new Man();
116         if(p2 instanceof Woman)
117         {
118             Woman w1 =(Woman)p2;
119             w1.goShopping();
120             System.out.println("******* Woman*****");
121         }
122         
123         
124         
125         if(p2 instanceof Man)
126         {
127             Man m2 =(Man)p2;
128             m2.makeMoney();
129             System.out.println("******* Man*****");
130         }
131         
132         if(p2 instanceof Person)
133         {
134             System.out.println(" ************  Person *********");
135         }
136         
137         if(p2 instanceof Object)
138         {
139             System.out.println("---------- Object ----------");
140         }
141         
142         
143         
144         
145         //练习：
146         //问题一：编译通过，运行不通过
147           //举例一
148 //        Person p3= new Woman();
149 //        Man m3 = (Man)p3;
150         
151         //举例二
152 //        Person p4 = new Person();   //不可以
153 //        Man m4 = (Man)p4;
154     
155         
156         
157         //问题二：编译通过  运行通过  父类的父类   Woman 子类
158 //        Object obj = new Woman();   //可以的
159 //        Person p = (Person)obj;
160         
161         
162         //问题三  编译不通过
163         
164         // Man m5 =  new  Woman();  类型不匹配，没有任何关系，鄙必须是子父类
165         
166         //String str = new Date();
167         
168 //        Object p = new Date();
169 //        String str1 = (String) p;
170     }
171 }

 1 package com.bytezreo.duotai2;
 2 
 3 public class Person 
 4 {
 5     String name;
 6     int age;
 7     
 8     int id = 1001;
 9     
10     public void eat()
11     {
12         System.out.println("人，吃饭");
13     }
14     public void walk()
15     {
16         System.out.println("人，走路");
17     }
18     
19     
20     
21     
22     
23 }

 1 package com.bytezreo.duotai2;
 2 
 3 public class Man extends Person
 4 {
 5     boolean isSmoking;
 6     
 7     int id = 1002;
 8     
 9     public void makeMoney()
10     {
11         System.out.println("男人养家家,挣钱");
12     }
13     
14     //重写
15     public void eat()
16     {
17         System.out.println("男人多吃吃饭");
18     }
19     public void walk()
20     {
21         System.out.println("男人霸气走路");
22     }
23     
24     
25     
26 }

 1 package com.bytezreo.duotai2;
 2 
 3 public class Woman extends Person
 4 {
 5         boolean isBeauty;
 6         
 7         public void goShopping()
 8         {
 9             System.out.println("女人喜欢购物");
10         }
11         
12         //重写
13         public void eat()
14         {
15             System.out.println("女人吃饭，减肥");
16         }
17         public void walk()
18         {
19             System.out.println("女人窈窕的走路");
20         }
21         
22 }

  1 package com.bytezreo.duotai2;
  2 
  3 //多态性的使用 举例一
  4 public class AnimalTest
  5 {
  6     public static void main(String[] args) 
  7     {
  8         AnimalTest test = new AnimalTest();
  9         test.func(new Dog());
 10         
 11         
 12         test.func(new Cat());
 13         
 14         
 15     }
 16     
 17     //声明是 animal          Animal animal = new Dog();
 18     public void func(Animal animal)
 19     {
 20         animal.eat();
 21         animal.shout();
 22         
 23         if(animal instanceof Dog )
 24         {
 25             Dog d = (Dog)animal;
 26             d.watchDoor();
 27         }
 28         
 29         
 30         
 31     }
 32     
 33     
 34     
 35     //没有多态性的时候
 36 //    public void func(Dog dog)
 37 //    {
 38 //        dog.eat();
 39 //        dog.shout();
 40 //    }
 41 //    
 42 //    public void func(Cat cat)
 43 //    {
 44 //        cat.eat();
 45 //        cat.shout();
 46 //    }
 47 //    
 48 //    
 49     
 50 }
 51 
 52 class Animal
 53 {
 54     public void eat()
 55     {
 56         System.out.println("动物：进食");
 57     }
 58     public void shout()
 59     {
 60         System.out.println("动物：叫");
 61     }
 62     
 63     
 64     
 65     
 66     
 67 }
 68 
 69 class Dog extends Animal
 70 {
 71     public void eat()
 72     {
 73         System.out.println("狗：吃骨头");
 74     }
 75     public void shout()
 76     {
 77         System.out.println("狗：汪汪汪");
 78     }
 79     
 80     public void watchDoor()
 81     {
 82         System.out.println("看门");
 83     }
 84 }
 85 
 86 
 87 
 88 class Cat extends Animal
 89 {
 90     public void eat()
 91     {
 92         System.out.println("猫：吃大鱼");
 93     }
 94     public void shout()
 95     {
 96         System.out.println("猫：喵喵喵");
 97     }
 98 }
 99 
100 //举例二
101 
102 class Order
103 {
104     public void method(Object obj)
105     {
106         
107     }
108 }

这篇关于Java instanceof 全小写 关键字使用的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！