黑马程序员——Java面向对象(三)

                      ------- android培训、java培训、期待与您交流！ ----------

                                   面向对象(三)

 多态

 某一种事物的多种存在形态。

 

 1：多态的体现。

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

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

 2：多态的前提。

    必须是类与类之间有关系，要么继承，要么实现。通常还有一个前提覆盖。

 3：多态的好处。

    多态的出现大大提高了程序的扩展性。

 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()//复写抽象类Student中的study方法
{
System.out.println("坐着睡");
}
}
class Advstudent extends Student
{
public void study()//子类实现抽象类中的抽象方法
{
System.out.println("adv study");
}
public void sleep()//复写抽象类Student中的study方法
{
System.out.println("躺着睡");
}
}
class Dostudet
{
public void dosome(Student stu)
{
stu.sleep();
stu.study();
}
}






class DuotaiDemo1
{
public static void main(String[] args) 
{
Dostudet ds = new Dostudet();//建立Dostudet对象
ds.dosome(new Basestudent());//调用dosome方法new Basestudent()访问Basestudent
ds.dosome(new Advstudent());//调用dosome方法new Advstudent()访问Advstudent
}
}

     

    

    内部类

   将一个类定义在另一个类中，里面那个类就称为内部类(内置类，嵌套类)。

   

   内部类的访问规则

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

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

   建立对象的格式：

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

                                   Outer.Inter  in = new Outer().new Inter()。

  只有内部类可以被私有其它类则不行。内部类之所以可以访问外部类成员，是因为内部类中持有了一个外部类的引用，格式为外部类名称.this.

 当内部类在成员的位置上时，就可以被成员修饰符修饰。

 

 比如：private：将内部类在外部类中封装。

                  

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

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

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

 

             

    写在方法中的内部类称为局部内部类，此时就不能被私有静态修饰，因为私有和静态不能修饰局部。

 

     内部类定义在局部时：

   1：不可以被成员修饰符修饰。

   2：可以直接访问外部类中的成员，因为还持有外部类中的引用，但是不可以访问它所在的局部中的变量，只能访问被final修饰的局部变量。

   

  匿名内部类：1：匿名内部类其实就是内部类的简写格式。

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

    匿名内部类的格式：

                

                                        new 父类或者接口() {定义子类内容}

//利用匿名内部类查找所有的.java文件
        File[] files = root.listFiles(new FilenameFilter() 
        {    
public boolean accept(File dir, String name) 
{  
                        return name.endsWith(".java");  
                 }  
         } );  
          

 

   一个匿名对象只能调用一次方法。匿名内部类中定义的方法最好不要超过三个。

class Test06 
{
public static void main(String[] args) 
{
A.B ab = new A().new B();//直接建立内部类对象
ab.func();//调用内部类方法
}
}
class A 
{
int x = 1;
class B 
{
int x = 2;
void func()
{
int x = 3;
System.out.println("Ax="+A.this.x+" Bx="+this.x+" x="+x);
        }//用this关键字明确x的所属对象
    }
}

                          ------- android培训、java培训、期待与您交流！ ----------