黑马程序员---java基础----面向对象3

 ------ Java培训、Android培训、iOS培训、.Net培训 、期待与您交流！ -------

面向对象

Day8

******1Object类toString（）

1.toString

             public String toString()返回该对象的字符串表示。
             通常，toString方法会返回一个“以文本方式表示”此对象的字符串。
             结果应是一个简明但易于读懂。建议所有子类都重写此方法。

******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 Lookhome()
{
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) 
{
/*Animal c = new Cat();
function(c);
Animal d = new Dog();
d.Lookhome();
function(d);
function(new Dog());*/
Animal a = new Cat();  //类型提升。相上转型
function(a);
//如果想要调用猫的特有方法时，如何操作？
//强制将父类的引用转成子类类型。向下转型
Cat c = (Cat)a; 
c.catchMouse();
        ******3
//千万不要出现这样的操作，就是讲父类对象转成子类类型。
               //我们能转换的是父类应用指向了自己的子类对象时，该应用可以被提升，也可以被强制转换。
            //多态自始至终都是子类对象在做着变化。
}
    public static void function(Animal a)
{ 
a.eat();
if(a instanceof Cat)
{
cat c = (cat)a;
c.catch();
}
else if(a instanceof  Dog ) //instanceof 用于判断 
{
Dog d  = (Dog)a;
d.Lookhome();
}
     }
/*
    public static void function(Cat c)
{
c.eat();
}
public static void function(Dog d)
{
d.eat();
}
 public static void function(Pig p)
{
p.eat();
}
*/

******4多态实例

abstract class Student 
{
public  abstract  void  study();
public  void sleep()
{
System.out.println("躺着睡");
}
}
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 DoStudent
{
public void function(Student s)
{
         s.study();
  s.sleep();
}
}
class  DuoTaiDemo2
{
public static void main(String[] args) 
{
DoStudent d = new DoStudent();
d.function(new baseStudent());
d.function(new advStudent());
}	
}

******5多态中成员的特点

1.在多态中成员函数（一般指非静态的）的特点：

在编译时期
        参阅 引用类型变量(左边)所属的类中 是否有调用的方法。

        如果有，编译通过，如果没有编译失败。

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

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

2.面试重点

              在多态中， 成员变量 的特点
              无论编译与运行都参照左边（引用型变量所属的类）           

3.面试重点

                在多态中，静态成员函数的特点：

                无论编译和运行，都看左边。

            静态看类绑定，动态看对象绑定

                 静态成员函数，看左边

例1：
class Fu
{
void mesthod1()
{
System.out.println("fu_1");
}
void mesthod2()
{
System.out.println("fu_2 ");
}
}
class Zi extends Fu
{
void mesthod1()
{
System.out.println("Zi_1 ");
}
void mesthod3()
{
System.out.println("Zi_3 ");
}
}
class  DuoTaiDemo4
{
public static void main(String[] args) 
{
Fu f = new Zi();
f.mesthod1();
f.mesthod2();
f.mesthod3();
}
}

例2：
class Fu
{
    int num=5;
}
class Zi extends Fu
{    
    int num=8;
}
public static void main(String[] args)
{
        Fu f = new Zi();
        System.out.println(f.num);
        zi z = new Zi();
        System.out.println(z.num);
}
结果：5    8
在多态中，成员变量的特点：
无论编译与运行都 参考左边（引用型变量所属的类）

******6多态的主板实例

掌握思想，注意接口的使用

/*
需求：
电脑运行实例，电脑运行基于主板。
*/
//建立PCI接口，进行过程的简化
interface PCI
{
public abstract void open();
public abstract void stop();
}
//建立主板
class MainBoard
{
public void run()
{
System.out.println("MainBoard _run");
}
public void usePCI(PCI p)
{
if(p!=null)
{
p.open();
p.stop();
}
}
}
//建立网卡
class NetCard   implements PCI
{
public void open()
{
System.out.println("NetCard open");
}
public void stop()
{
System.out.println("NetCard stop");
}
}
//声卡建立
class MusicCard   implements PCI
{
public void open()
{
System.out.println("MusicCard open");
}
public void stop()
{
System.out.println("MusicCard stop");
}
}
class  DuoTaiDemo5
{
public static void main(String[] args) 
{
MainBoard m = new MainBoard();
m.run();
m.usePCI(null);
m.usePCI(new NetCard());
m.usePCI(new MusicCard());
}
}

******7多态的扩展示例

数据库的链接

需求：数据库操作

1.链接数据库。JDBC、Hibernate

2.操作数据库：c create r read u update  d  delete

3.关闭数据库。

interface  useInfoDAO
{
       void add();
       void delete(）;
}
class dateByHebernate
{
    public void add(){}
    public void delete() {}
}

******8Object 类 equals()

1.附加点

              java 中的instanceof 运算符是用来在运行时 指出对象是否是特定类的一个实例。
              instanceof通过返回一个布尔值来指出，这个对象是否是这个特定类或者是它的子类的一个实例。

 2.用法

              result = object instanceof class

3.参数

               Result：布尔类型。
              Object：必选项。任意对象表达式。
              Class：必选项。任意已定义的对象类。

4.说明

             如果 object 是 class 的一个实例，则 instanceof 运算符返回 true。
             如果 object 不是指定类的一个实例，或者 object 是 null，则返回 false。

​2.class A   class  B

          这些class文件都有名称，都有构造函数，一般方法.(以上为共性)

  

          Class用来描述这些class文件

1.Class类  常用方法  getName()   getMethods()
2.Object所有对象的父类，常用方法  equals()
/*
Object：是所有对象的直接或者间接父类。
该类中定义的肯定是所有对象都具备的功能。
*/
class Demo 
{
private int num;
Demo(int num)
{
this.num = num;
}
public boolean equals(Object obj)
{
if(!(obj instanceof Demo))//instanceof 用法在上面
return false;
Demo d  = (Demo)obj;//将obj向下转换为Demo类型
 return d.num==this.num;  //进行比较是否相等，此处比较的是对象中的num值是否相等
}
}

******8Object 类 toString()

class  ObjectDemo 
{
public static void main(String[] args) 
{
    Demo d1 = new Demo(4);
       // Demo d2 = new Demo(5);
//d1.equals(d2);//equals 用法
        //Person p = new Person();
//d1.equals(p);
Class c = d1.getClass();
System.out.println(c.getName()+"@@"+Integer.toHexString(d1.hashCode()));//
}
}

Day9  面向对象

******1  内部类访问规则

类中可以建立类。

内部类的访问规则：

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

              之所以可以直接访问外部类中的成员是 因为内部类中特有了一个外部类的引用，

               格式   --   外部类名.this      

            2.外部类要访问内部类，必须先建立内部类对象。

            3.访问格式：

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

            格式：

                  外部类名.内部类名   变量名 = 外部对象.内部对象

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

          4.当内部类在成员位置上时，就可以被成员修饰符所修饰。如：

                 private：将内部类在外部类中进行封装。

                 static：内部类就具备static的特性。

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

          5. 在外部其他类中直接访问static内部类中的非静态成员：

             new Outer.Inner().function();

             在外部其他类中直接访问static内部类的静态成员：

            Outer.Inner（）.function();

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

以上注意书写格式，为面试考点。知识点了解即可。

class Outer
{
private int x = 3;
class Inner
{
int x = 7;
void function()
{
int x = 9;
                        System.out.println("x"+x);   ----------结果：9  类中有即为类中成员变量。就近原则
                        System.out.println("x"+this.x);          ----------：this.x调用所属类中成员变量
                                                                                               若类中无成员变量，则编译出错。
System.out.println("x"+Outer.this.x);              -------：3  this前加类名，
                                                           表示为Inner（内部类）所属的外部类中的成员变量。
}
}
void method()
{
System.out.println(x);
}
        static class Inner2
{
void show()
{
System.out.println("Inner2 show");
}
}
public static  void  method2()
{
//Inner.method();
new Inner2().show();
}
}
class  InnerClassDemo
{
public static void main(String[] args) 
{
Outer.Inner in = new Outer().new Inner();   外部类要访问内部类，必须先建立内部类对象。
in.function();
}
}

******3内部类定义规则

当描述事物时，事物的内部还有事物，该事物用内部类来描述。

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

******4匿名内部类（匿名对象只能对方法调用一次）

一、内部类定义在局部时

   内部类定义在局部时

1.不可以被成员修饰符修饰

  如下：

          void  function若被static修饰，则内部类Inner必为static，

  但是class Inner定义在局部方法内部，不能被static修饰。

  因为只有成员才能被static修饰。

          故：内部类定义在局部时不能被修饰符修饰。

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

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

class Outer
{
int x = 3;
void method(final int a)
{
final int y = 4;
class Inner          //.不可以被成员修饰符修饰
{
void function()
{
System.out.println(a);
}
}
new Inner().function();   //放在class后
}
}
class  InnerClassDemo
{
public static void main(String[] args) 
{
Outer out = new Outer();
out.method(7);
out.method(8);
}
}

二、匿名内部类：

1.匿名内部类

          其实就是内部类的简写格式。

2.定义匿名内部类的前提：

           内部类必须是继承一个类或者实现接口

3.匿名内部类的格式

          new 父类或者接口（）{定义子类内容}

 (1)
abstract class Demo
{
abstract void show();
}
class Outer
{
int x = 3;
        
      /*  建立匿名对象与如下操作相同，注意要继承抽象类或者实现接口。 
        class  Inner extends Demo
       {
              Inner in = new Inne();？？？？
              public  void show()
             {
                    System.out.println("x:"+x);
              }
       }
    */
public void function()
{
new Demo()
{
void show()
{
System.out.println("x:"+x);
}
}.show();
}
}
class  InnerClassDemo
{
public static void main(String[] args) 
{
new Outer().function();
}
}

4.匿名内部类就是一个匿名子类对象。

interface  Inter
{
void method();
}
class Test
{
//补足代码
static Inter function()
{
return new Inter()
       {

             public void method()
    {
        System.out.println("run");
    }

};
}
}
class  InnerClassTest
{
public static void main(String[] args) 
{
Test.function().method();
}
}

三.面试题

在没有抽象类和接口的条件下，如何建立匿名类

class Demo2

{

public static void main(String[] args)

{

new Object()

{       //这是 Object 子类对象

public void function()

{

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

}

}.function();

}

}

此处若为：Object o =  new Object()

{       //子类对象

public void function()

{

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

}

}.function();

错误:这是Object子类对象，不是Object对象，因为Object对象中没有function（）方法。所以不要建立引用。

 ------ Java培训、Android培训、iOS培训、.Net培训 、期待与您交流！ -------

---