——Diary5(Java面向对象2——多态，内部类)

                                                              

面向对象2

多态 可以理解为  事物存在的多种体现形式

1：多态在程序中的体现

         父类的引用指向了自己子类的对象

         父类的引用也可以接受自己子类的对象

2：多态的前提

        必须是类与类之间有关系，要么继承要么实现，

存在覆盖

3：多态的好处

        大大提高了程序的扩展性

4：多态的弊端

        只能使用父类的引用访问父类中的成员

5：多态的应用

abstract class Animal

{

 abstract void eat();

}

class Cat extends Animal

{

 public void eat()

 {

  System.out.println("吃鱼");

 }

 public void catchMouse()

 {

  System.out.println("抓老鼠");

 }

}

class Dog extends Animal

{

 public void eat()

 {

  System.out.println("吃骨头");

 }

 public void kanJia()

 {

  System.out.println("看家");

 }

}

class Pig extends Animal

{

 public void eat()

 {

  System.out.println("饲料");

 }

 public void gongDi()

 {

  System.out.println("拱地");

 }

}

class DuoTaiDemo

{

 public static void main(String[] args)

 {

  //Cat c = new Cat();

  //c.eat();

  //Dog d = new Dog();

  //d.eat();

  //Cat c = new Cat();

  //Animal c = new Cat(); // 类型提升   也称为向上转型

//如果想要调用猫的特有方法，怎么操作？ ： 强制将父类的引用转成子类类型。向下转型；

//多态始终是子类对象在做着变化

  //c.eat();

 

  function(new Cat());

  function(new Dog());

  function(new Pig());

 }

 public static void function(Animal a) //多态

 {

  a.eat();

 }

 /*

 public static void function(Animal c)

 {

  c.eat();

  if（c instanceof Cat）{

        Cat cc=(Cat)c; //向下转型，强制将父类的引用，转成子类类型

        c.catchMouse();

//千万不要出现这样的操作，就是将父类对象转成子类类型

//我们能转换的是父类引用已经指向了自己的子类对象时，该引用才可以被向下转型

//Animal a=new Animal();

//Cat c =(Cat)a;

//多态至始至终都是子类对象在做着变化

}

 }

 public static void function(Dog d)

 {

  d.eat();

 }

 */

}

------------------------------------------------------------------- -----------------------------------------------------------------------------

多态 注意事项

基础班学生：

  学习，睡觉。

高级班学生：

  学习，睡觉。

可以将这两类事物进行抽取。

abstract class Student

{

 public abstract void study();

 public void sleep()

 {

  System.out.println("躺着睡");

 }

}

class DoStudent    //抽取：相当于工具类

{

 

 public void doSome(Student stu)

 {

  stu.study();

  stu.sleep();

 }

 

}

----------------------------------------------------

class BaseStudent extends Student

{

 public void study()

 {

  System.out.println("base study");

 }

 public void sleep()

 {

   System.out.println("坐着睡");

 }

}

class AdvStudent extends Student

{

 public void study()

 {

  System.out.println(" adv study");

 }

}

class DuoTaiDemo3

{

 public static void main(String[] args)

 {

  DoStudent ds = new DoStudent();

  ds.doSome(new BaseStudent());

  ds.doSome(new AdvStudent());

 }

}

------------------------------------- ------------- ----------------------------------------------------------------------------------

※多态中成员的特点

函数特点：

编译时：参阅引用型变量所属的类中是否有调用的方法。 如果有，编译通过；否则， 编译失败。

运行时：参阅对象所属的类中是否有调用的方法

总结：成员函数在多态调用时，编译看左边，运行看右边。

多态中， 成员变量：无论编译运行都参考左边（引用型变量所属的类）

多态中， 静态函数：不论编译和运行都参考左边

--------------------------------------------- --------------- ---------------------------------------------------------------------------------

多态的主板示例

interface  PCI

{

    public void open（）；

    public void close（）；

}

class  NerCard  implements PCI    //网卡

{

    public void open(){ System.out.println("NerCard  open");  }

     public void close (){ System.out.println("NerCard  close ");  }

}

class  SoundCard  implements PCI  //声卡

{

    public void open(){ System.out.println("SoundCard  open");  }

     public void close (){ System.out.println("SoundCard  close ");  }

}

class  MainBoard  //主板

{

    public void run（）{

            System.out.println("MainBoard  run");

        }

    public void usePCI（PCI p） //多态：接口型引用指向实现类的对象

  {        

   if(p!=null){

            p.open();

            p.close();

        }

        }

}

class DuoTaiDemo

{

 public static void main(String[] args)

 {

        MainBoard m=new MainBoard();

        m.run();

        m.usePCI(null);

        m.usePCI(new NerCard ( ) );

        m.usePCI(new SoundCard  ( ) );

     

 }

} 

-------------------------------------------------------------------------------------------------------------------------------

多态的扩展示例

需求：数据库的操作

1：连接数据库

2：操作数据库

        增删改查 create read update delete

3：关闭数据库连接

class  UserInfoByJdbc{

    public void  add（User user）{

            jsbc 连接数据库操作；

    }

}

class   UserInfoByHibernate implements UserInfoDao{

    public void  add（User user）{

           Hibernate连接数据库操作；

    }

}

interface UserInfoDao{

    public void add();

}

class DBoperate  implements UserInfoDao{

        public static void main(String args[]){

           /* UserInfoByJdbc   uj=new UserInfoByJdbc   ();

            UserInfoByHibernate uh=new UserInfoByHibernate ();*/

     UserInfoDao ud= new UserInfoByJdbc   ()  ;

     ud.add();

}

}

---------------------------------------------------------------------------------- ------------------------------

Object 类   

 -equals()；

Object 类的 equals 方法实现对象上差别可能性最大的相等关系；即，对于任何非空引用值 x 和 y，当且仅当 x 和 y 引用同一个对象时，此方法才返回 true（ x == y 具有值 true）。

Object  是所以对象的直接或间接父类， 该类中定义的肯定是所有对象都具有的功能

java认为所有对象都具有比较性

Object  equals（Object  o）中的多态

Object 类 -  toString()；

getClass().getName() + '@' + Integer.toHexString(hashCode())；

《黑马程序员 java 基础 毕向东 第8天 面向对象 多态》多态，多态中成员的特点※，Object类(equals，toString，hashCode)

内部类

内部类的访问规则：

1：内部类可以直接访问外部类的成员，包括私有 的

2：外部类访问内部类，必须建立内部类对象

内部类可以被private修饰。

之所以可以直接访问外部类的成员，因为内部类持有内部类的引用，写法为：外部类名.this

而 外部类访问内部类，必须先建立内部类的对象

访问内部类中成员格式：

1：当内部类定义在外部类的成员位置上，且非私有，可以在外部其他类中 直接建立内部类对象

格式： 外部类名.内部类名   变量名=外部类对象.内部类对象；

直接访问内部类的成员(当内部类不被private修饰时)：

Outer.Inner   in=new Outer().new Inner();

in.function();

2：当内部类在成员位置上，就可以被成员修饰符修饰，

比如private：将内部类在外部类中进行封装；

static ：内部类就具备了静态特性；

当内部类被static修饰后只能访问外部类中的static成员，出现访问局限。

在外部其它类中，如何直接访问static内部类的非静态成员呢？

new Outer.Inner().function();

在外部其它类中，如何直接访问static内部类的静态成员呢？

 Outer.Inner.function();

注意：当内部类中定义了静态成员，该内部类必须是static的。

  当内部类中的静态方法访问内部类时，内部类也必须是static的。

当描述事物时，事物内部还有事物，该事物用内部类表示

因为内部类事物在使用外部事物的内容

class Body

{

private class Heart

{} 

public void show()

{new Heart();}

}

局部内部类不能被static修饰，所以局部内部类中没有static成员。

当内部类定义在局部时：

*不可以被成员修饰符修饰

*可以直接访问外部类中的成员，因为还持有外部类的引用。

  但是不可以访问它所在的局部中不被final修饰的局部变量。

匿名内部类：

1：就是内部类的简写格式

2：定义匿名内部类的前提：  内部类必须继承一个类或者实现接口

3：匿名内部类的格式：

            new 父类或者接口(){

                    定义子类的内容

            }

若想多次调用：

父类或接口名  引用=new  父类或接口名(){

      void func();

};

匿名内部类做函数实参：

show(new Iter()

{

public void func();

});

4：匿名内部类就是一个匿名子类对象，这个对象有点胖，也可以理解为带内容的对象

5：匿名内部类中定义的方法最好不要超过3个