Java 学习 day08

01-面向对象(多态-概念)

 1 package myFirstCode;
 2 
 3 /*
 4 多态：可以理解为事务存在的多种体现形态。
 5 
 6 人：男人，女人
 7 
 8 动物：猫，狗
 9 
10 
11 猫 x = new 猫();
12 
13 动物 x = new 猫();
14 
15 1. 多态的体现
16 2. 多态的前提
17 3. 多态的好处
18 4. 多态的应用
19 
20  */
21 
22 
23 
24 public class DuoTailDemo {
25 
26     public static void main(String[] args) {
27         // TODO Auto-generated method stub
28 
29     }
30 
31 }
View Code

02-面向对象(多态-扩展性)

  1 package myFirstCode;
  2 
  3 /*
  4 多态：可以理解为事务存在的多种体现形态。
  5 
  6 人：男人，女人
  7 
  8 动物：猫，狗
  9 
 10 
 11 猫 x = new 猫();
 12 
 13 动物 x = new 猫();
 14 
 15 1. 多态的体现
 16     父类的引用指向了自己的子类对象。
 17     父类的引用也可以接收自己的子类对象。
 18     
 19 2. 多态的前提
 20     必须是类与类之间有关系。要么继承，要么实现。
 21     通常还有一个前提：存在覆盖。
 22     
 23 3. 多态的好处
 24     多态的出现大大的提高了程序的扩展性。
 25     
 26 4. 多态的弊端
 27     提高了扩展性，但是只能使用父类的引用访问父类中的成员。
 28     
 29 5. 多态的应用
 30 
 31  */
 32 
 33 abstract class Animal 
 34 {
 35     abstract void eat();
 36 }
 37 
 38 class Cat extends Animal
 39 {
 40     public void eat()
 41     {
 42         System.out.println("吃鱼");
 43     }
 44     
 45     public void catchMouse()
 46     {
 47         System.out.println("抓老鼠");
 48     }
 49     
 50 }
 51 
 52 class Dog extends Animal
 53 {
 54     public void eat()
 55     {
 56         System.out.println("吃骨头");
 57     }
 58     public void kanjia()
 59     {
 60         System.out.println("看家");
 61     }
 62 }
 63 
 64 class Pig extends Animal
 65 {
 66     public void eat()
 67     {
 68         System.out.println("饲料");
 69     }
 70     public void gongDi()
 71     {
 72         System.out.println("拱地");
 73     }
 74 }
 75 
 76 
 77 public class DuoTailDemo {
 78 
 79     public static void main(String[] args) {
 80         // TODO Auto-generated method stub
 81         /*
 82         Cat c = new Cat();
 83         c.eat();
 84         Dog d = new Dog();
 85         d.eat();
 86         Cat c = new Cat();
 87         function(c);
 88         Dog d = new Dog();
 89         function(d);
 90          */    
 91         
 92 //        Animal c = new Cat();
 93 //        c.eat();
 94         
 95         function(new Cat());
 96         function(new Dog());
 97         function(new Pig());
 98     }
 99     public static void function(Animal a)//Animal a = new Cat();
100     {
101         a.eat();
102     }
103     /*
104     public static void function(Cat c)
105     {
106         c.eat();
107     }
108     public static void function(Dog d)
109     {
110         d.eat();
111     }
112     */
113 
114 }
View Code

03-面向对象(多态-转型)

  1 package myFirstCode;
  2 
  3 /*
  4 多态：可以理解为事务存在的多种体现形态。
  5 
  6 人：男人，女人
  7 
  8 动物：猫，狗
  9 
 10 
 11 猫 x = new 猫();
 12 
 13 动物 x = new 猫();
 14 
 15 1. 多态的体现
 16     父类的引用指向了自己的子类对象。
 17     父类的引用也可以接收自己的子类对象。
 18     
 19 2. 多态的前提
 20     必须是类与类之间有关系。要么继承，要么实现。
 21     通常还有一个前提：存在覆盖。
 22     
 23 3. 多态的好处
 24     多态的出现大大的提高了程序的扩展性。
 25     
 26 4. 多态的弊端
 27     提高了扩展性，但是只能使用父类的引用访问父类中的成员。
 28     
 29 5. 多态的应用
 30 
 31  */
 32 
 33 abstract class Animal 
 34 {
 35     abstract void eat();
 36 }
 37 
 38 class Cat extends Animal
 39 {
 40     public void eat()
 41     {
 42         System.out.println("吃鱼");
 43     }
 44     
 45     public void catchMouse()
 46     {
 47         System.out.println("抓老鼠");
 48     }
 49     
 50 }
 51 
 52 class Dog extends Animal
 53 {
 54     public void eat()
 55     {
 56         System.out.println("吃骨头");
 57     }
 58     public void kanjia()
 59     {
 60         System.out.println("看家");
 61     }
 62 }
 63 
 64 class Pig extends Animal
 65 {
 66     public void eat()
 67     {
 68         System.out.println("饲料");
 69     }
 70     public void gongDi()
 71     {
 72         System.out.println("拱地");
 73     }
 74 }
 75 
 76 
 77 public class DuoTailDemo2 {
 78 
 79     public static void main(String[] args) {
 80 //        Animal a = new Cat();//类型提升。向上转型、向下转型。
 81 //        a.eat();
 82         
 83         //如果想要调用猫的特有方法时，如何操作？
 84         //强制将父类的引用。转换成子类类型。向下转型。
 85 //        Cat c = (Cat)a;
 86 //        c.catchMouse();
 87         
 88         //千万不要出现这样的操作，就是将父类对象转成子类类型。
 89         //我们能转换的是父类应用指向了自己的子类对象时，该应用可以被提升，也可以被强制转换。
 90         //多态自始至终都是子类对象在做着变化。
 91 //        Animal a = new Animal();
 92 //        Cat c = (Cat)a;
 93         
 94         /*
 95         毕姥爷 x = new 毕老师();
 96         
 97         x.讲课();
 98         
 99         毕老师 y = (毕老师)x;
100         y.看电影();
101         //x.看电影(); 没有看电影的方法
102         */
103         function(new Dog());
104         function(new Cat());
105     }
106     public static void function(Animal a)//Animal a = new Cat();
107     {
108         a.eat();
109         /*
110         if(a instanceof Animal)
111         {
112             System.out.println("haha")
113         }
114          */
115         if(a instanceof Cat)
116         {
117             Cat c =  (Cat)a;
118             c.catchMouse();
119         }
120         else if(a instanceof Dog)
121         {
122             Dog c =  (Dog)a;
123             c.kanjia();
124         }
125     }
126 
127 }
View Code

04-面向对象(多态-示例)

 1 package myFirstCode;
 2 
 3 /*
 4 基础班学生：
 5     学习，睡觉。
 6 高级班学生：
 7     学习，睡觉。
 8     
 9 可以将这两类事务进行抽取。
10  */
11 
12 abstract class Student5
13 {
14     public abstract void study();
15     public void sleep()
16     {
17         System.out.println("躺着睡");
18     }
19 }
20 
21 class DoStudent
22 {
23     public void doSome(Student5 stu)
24     {
25         stu.study();
26         stu.sleep();
27     }
28 }
29 
30 //-----以上是工具类
31 
32 
33 class BaseStudent2 extends Student5
34 {
35     public void study()
36     {
37         System.out.println("base study");
38     }
39     public void sleep()
40     {
41         System.out.println("坐着睡");
42     }
43 }
44 
45 class AdvStudent2 extends Student5
46 {
47     public void study()
48     {
49         System.out.println("adv study");
50     }
51     public void sleep()
52     {
53         System.out.println("坐着睡");
54     }
55 }
56 
57 
58 
59 public class DuoTailDemo3 {
60 
61     public static void main(String[] args) 
62     {
63         DoStudent ds = new DoStudent();
64         ds.doSome(new BaseStudent2());
65         ds.doSome(new AdvStudent2());
66         
67 //        BaseStudent2 bs = new BaseStudent2();
68 //        bs.sleep();
69 //        bs.study();
70 //        AdvStudent2 as = new AdvStudent2();
71 //        bs.sleep();
72 //        bs.study();
73     }
74 }
View Code

05-面向对象(多态中成员的特点)

 1 package myFirstCode;
 2 
 3 class Fu3
 4 {
 5     void method1()
 6     {
 7         System.out.println("fu method1");
 8     }
 9     void method2()
10     {
11         System.out.println("fu method2");
12     }
13 }
14 class Zi3 extends Fu3
15 {
16     void method1()
17     {
18         System.out.println("zi method1");
19     }
20     void method3()
21     {
22         System.out.println("zi method3");
23     }
24 }
25 
26 public class DuoTaiDemo4 {
27 
28     public static void main(String[] args) {
29         // TODO Auto-generated method stub
30         
31         Fu3 f = new Zi3();
32         f.method1();
33         f.method2();
34 //        f.method3();
35 /*
36  * 在多态中成员函数的特点：
37  * 在编译时期：参阅引用型变量所属的类中是否有调用的方法。如果有，编译通过，如果没有编译失败。
38  * 在运行时期：参阅对象所属的类中是否有调用的方法。
39  * 简单总结就是：成员函数在多态调用时，编译看左边，运行看右边。
40  * 
41  */
42         
43         
44         
45         
46 //        Zi3 z = new Zi3();
47 //        z.method1();
48 //        z.method2();
49 //        z.method3();
50 
51     }
52 
53 }
View Code

06-面向对象(多态的主板示例)

 1 package myFirstCode;
 2 
 3 import classOne.IfClause;
 4 
 5 /*
 6  * 需求：
 7  * 电脑运行实例，
 8  * 电脑运行基于主板。
 9  */
10 
11 interface PCI
12 {
13     public void open();
14     public void close();
15 }
16 
17 class MainBoard
18 {
19     public void run()
20     {
21         System.out.println("mainboard run");
22     }
23     public void usePCI(PCI p)//PCI p = new NetCard() //接口型引用指向自己的子类对象。
24     {
25         if (p!=null)
26         {
27             p.open();
28             p.close();        
29         }
30     }
31 }
32 
33 class NetCard implements PCI
34 {
35     public void open()
36     {
37         System.out.println("netcard open");
38     }
39     public void close()
40     {
41         System.out.println("netcard close");
42     }
43 }
44 class SoundCard implements PCI
45 {
46     public void open()
47     {
48         System.out.println("soundcard open");
49     }
50     public void close()
51     {
52         System.out.println("soundcard close");
53     }
54 }
55 
56 /*
57 class MainBoard
58 {
59     public void run()
60     {
61         System.out.println("manboard run");
62     }
63     public void useNetCard(NetCard c)
64     {
65         c.open();
66         c.close();
67     }
68 }
69 
70 class NetCard
71 {
72     public void open()
73     {
74         System.out.println("netcard open");
75     }
76     public void close()
77     {
78         System.out.println("netcard close");
79     }
80 }
81 */
82 
83 public class DuoTaiDemo5 {
84 
85     public static void main(String[] args) 
86     {
87         // TODO Auto-generated method stub
88         MainBoard mb = new MainBoard();
89         mb.run();
90         mb.usePCI(null);
91         mb.usePCI(new NetCard());
92         mb.usePCI(new SoundCard());
93     }
94 
95 }
View Code

07-面向对象(多态的扩展示例)

 1 package myFirstCode;
 2  /*
 3   * 需求：数据库的操作。
 4   * 
 5   * 数据是：用户信息。
 6   * 1. 连接数据库。JDBC Hibernate
 7   * 2. 操作数据库。
 8   *     C create R read U update D delete
 9   * 3. 关闭数据库连接
10   */
11 
12 interface UserInfoDao
13 {
14     public void add(User user);
15     public void delete(User user);
16     
17 }
18 
19 
20 
21 class UserInfoByJDBC implements UserInfoDao
22 {
23     public void add(User user)
24     {
25         1. JDBC连接数据库
26         2. 使用sql添加语句添加数据
27         3. 关闭连接
28     }
29     public void delete(User user)
30     {
31         1. JDBC连接数据库
32         2. 使用sql添加语句删除数据
33         3. 关闭连接
34     }
35 }
36 
37 class UserInfoByHibernate implements UserInfoDao
38 {
39     public void add(User user)
40     {
41         1. Hibernate连接数据库
42         2. 使用sql添加语句添加数据
43         3. 关闭连接
44     }
45     public void delete(User user)
46     {
47         1. Hibernate连接数据库
48         2. 使用sql添加语句删除数据
49         3. 关闭连接
50     }
51 }
52 
53 public class DBOperate {
54     public static void main(String[] args) {
55         // TODO Auto-generated method stub
56 //        UserInfoByJDBC ui = new UserInfoByJDBC();
57 //        UserInfoByHibernate ui = new UserInfoByHibernate();
58         
59         UserInfoDao ui= new  UserInfoByJDBC();        //此处是多态
60         ui.add(user);
61         ui.delete(user);
62         
63 
64     }
65 
66 }
View Code

08-面向对象(Object类-equals())

 1 package myFirstCode;
 2 
 3 /*
 4  * Object：是所有对象的直接或者间接父类，传说中的上帝。
 5  * 该类中定义的肯定是所有对象都具备的功能。
 6  * 任何对象都具备比较相同的功能（地址）
 7  * 
 8  * 
 9  * Object 类中已经提供了对对象是否相同的比较方法。
10  * 
11  * 如果自定义类中也有比较相同的功能，没有必要重新定义。
12  * 只要沿袭父类中的功能，建立自己特有的比较内容即可。这就是覆盖。
13  */
14 
15 
16 class Demo //extends object 
17 {
18     private int num;
19     Demo(int num)
20     {
21         this.num = num;
22     }
23     
24     public boolean equals(Object obj)//Object obj = new Demo();
25     {
26         if (obj instanceof Demo) 
27             return false;
28         Demo d = (Demo)obj;
29         return this.num == d.num;
30         
31     }
32     /*
33     public boolean compare(Demo d)
34     {
35         return this.num == d.num;
36     }
37     */
38 }
39 
40 
41 public class ObjectDemo {
42 
43     public static void main(String[] args) {
44         Demo d1 = new Demo(4);
45         Demo d2 = new Demo(5);
46         
47         Demo d3  = d1;
48         System.out.println(d1.equals(d2));
49     }
50 
51 }
View Code

09-面向对象(Object类toString())

【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/SH-xuliang/p/7203302.html