java6-多态

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

1:抽象类

1，抽象函数一定在抽象类中。
2,抽象类和函数都必须被abstract关键字修饰。
3，抽象类不允许用new建立对象。
4,抽象类中的抽象函数要被使用必须由子类覆写所有的抽象方法后，建立子类对象调用。若没完全覆盖，子类还是抽象类。


抽象类和一般类基本相同
多了个抽象函数，可以定义要明确出现但是无法定义主体的抽象函数。
抽象类不可以实例化。
也可以不定义抽象函数，只是为了不能实例化。new对象。


abstract class Student
{
abstract void study();
}




2:接口


接口是对外暴露的规则，是程序的功能扩展。可以用来多实现。类与接口之间是实现关系，而且类可以继承一个类同时实现多个接口。接口与接口之间可以有继承关系。


接口中的函数都是抽象的。
interface用于定义接口
class用于定义类
特点：
1，接口中常见定义：常量，抽象方法。
2，接口中成员都有固定修饰符。
常量：public static final


函数：public abstract
成员都是public的
接口中有抽象函数，不可以创建对象。要由子类全部实现接口中函数才能创建对象。


接口可以被类多实现，也是蛮像的多继承。

接口与接口之间可以多继承。

interface A{//接口void eat(); }abstract class Student{//抽象函数abstract void study();void sleep(){System.out.println("sleep");}}class GoodStuent extends Student implements A{//实现接口void study(){}//实现父类抽象函数public void eat(){}}

总结：
抽象类和接口都不能new对象，接口中只能有抽象函数和常量，抽象类可以为了不能new对象定义成抽象类。接口之间可以继承。
类可以关联多个接口，类继承了抽象类或关联了接口后必须全部实现抽象函数才能new对象。


2:多态
体现：
父类的引用指向了自己的子类对象。
前提：
类与类之间必须有关系，要么继承，要么实现。有个前提要存在覆盖。
好处是极大的提高了程序的扩展性，弊端是只能使用父类的引用访问父类中的成员。


子类对象可以向上提升成父类类型，之后可以向下转换成子类类型。但是只能是子类转换。
instanceof：判断对象属于哪个类用的关键字。


多态中成员函数的特点：
成员函数在多态调用时，编译看左边类，运行看右边类。
静态成员函数，成员变量编译运行都看左边。


理解：
静态成员函数位于静态方法区，可以类名调用，没有this,super指向，哪个类创建，就用哪个类的方法。
成员变量位于堆内存中，对象不同位置不同。
成员函数有this,super指向，根据对象指向函数位置。

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 DuoTai{public static void main(String[] args){Animal a = new Cat();//类型提升，向上转型a.eat();//强制将父类的引用，转型成子类类型，向下转型。Cat c = (Cat)a;//不能将父类对象强行转化成子类对象类型//能转换的只是父类应用指向的子类对象//做转换的一直是子类对象}public static void function(Animal a){a.eat();//instanceof：实例判断关键字，判断一类型引用指向对象到底符合什么类型时用if(a instanceof Cat)//父类最后判断{Cat c = (Cat)a;c.catchMouse();}}}

class Demo{}class ObjectDemo{public static void main(String[] args){//建立两个对象Demo d1 = new Demo();Demo d2 = new Demo();//equals()用法System.out.println(d1.equals(d2));//toString()用法System.out.println(d1.toString());}}

Object类：类层次结构的根类。所有对象的直接或间接父类。


equals()对象是否相等


toString()对象的字符串的表现形式

3：内部类，
内部类可以直接访问外部类中的成员，包括私有。
因为内部类持有一个外部类的引用，格式为 外部类.this
外部类访问内部类，必须建立内部类对象。
内部类定义在外部类成员位置上，并且非私有，可以在其他外部类直接建立对象。
格式Outer.Inter in = new Outer().new Inner();
内部类在类成员位置上，相当于成员调用，建立对象相当于调用方法是调用new 对象();


内部类在成员位置上，就可以用成员修饰符修饰，private,static
static内部类就具有静态的特性
只能直接访问外部类中的静态成员。
其他外部类直接访问静态内部类的非静态成员格式为
new Outer.Sinner().function();
其他外部类直接访问静态内部类的静态成员格式为
Outer.Sinner.function();
当内部类中定义了静态成员，该内部类必须是静态的。
当外部静态函数访问内部类时，该内部类必须是静态的。
内部类在局部位置时
不能被成员修饰符静态，私有修饰。
不能访问它所在的局部变量，只能访问被final修饰的局部变量。
匿名内部类
就是内部类的简写格式,只能调用一次。
内部类必须继承一个类或实现接口。就是匿名子类对象。内部函数最好不超过3个。
new 父类或接口（）
{
覆写函数或实现函数


}.调用函数（）;

class Outer{//外部成员变量private int x = 1;//外部静态成员static int y = 5;//内部类class Inner//成员位置上可以私有{int x = 2;void function(){int x = 3;//可以直接调用外部类成员xSystem.out.println("inner"+x);//3System.out.println("inner"+this.x);//2System.out.println("inner"+Outer.this.x);//1}//静态内部类static class Sinner{void function(){System.out.println("inner"+y);//不能访问外部类的非静态成员x}static void function1(){System.out.println("inner"+y);//不能访问外部类的非静态成员x}}void method(){//外部类调用内部类成员必须建立内部类对象Inner in = new Inner();in.function}}class Demo{public static void main(String[] args){//直接访问内部类中成员的格式Outer.Inter in = new Outer().new Inner();in.function();//直接访问静态内部类非静态成员new Outer.Sinner().function();//直接访问静态内部类静态成员Outer.Sinner.function1();}}

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