您的位置：首页 > 编程语言 > Java开发

java 自学日志【七】---面向对象之多态

2013-04-15 23:52 302 查看
------android培训，java培训，期待与您交流------

面向对象之多态

多态：事物存在的多种形式体现形态。

多态的基本体现：1.父类的引用指向了自己的子类对象；
2.父类的引用也可以接收自己子类的对象；

多态的前提：1. 类与类直接有关系，要么继承，要么实现；
2.存在覆盖；

多态的好处与弊端： 提高了程序的扩展性，但是只能使用父类的引用访问父类的成员；

子类对象被父类引用：子类对象在向上转型。

将指向子类对象的父类应用转换成子类类型引用：向下转型。



如果想调用子类特有方法，如何操作？
强制将父类的引用转成子类的引用。多态自始至终是子类对象在做着变化。
class 毕姥爷

{}

class 毕老师 extends 毕姥爷

{}

毕姥爷 ly = new 毕老师();//毕老师向上转型为了毕姥爷。向上转型

毕老师 ls = (毕老师)ly; //将代表毕老师对象的父类引用ly强制转换成了毕老师类型。向下转型。



在多态中，非静态成员函数的特点：
1. 在编译时，参阅引用型变量所属的类中是否有调用的方法，如果有，编译通过，如果没有，编译失败；
2.在运行时，参阅对象所属的类中是否有调用的方法；
简单总结就是：成员函数在多态调用时，编译看左边，运行看右边。

在多态中，非静态成员变量的特点：
无论编译还是运行，都参考左边，即引用型变量所属的类；

在多态中，静态成员函数的特点：
无论编译还是运行，都参考左边，即引用型变量所属的类；静态可以直接用类名调用，无需创建对象；
class Fu
{
static int num = 5;
void method1()
{
System.out.println("fu method_1");
}
void method2()
{
System.out.println("fu method_2");
}
static void method4()
{
System.out.println("fu method_4");
}
}

class Zi extends Fu
{
static int num = 8;
void method1()
{
System.out.println("zi method_1");
}
void method3()
{
System.out.println("zi method_3");
}

static void method4()
{
System.out.println("zi method_4");
}
}
class  DuoTaiDemo4
{
public static void main(String[] args)
{

//		Fu f = new Zi();
//
//		System.out.println(f.num);
//
//		Zi z = new Zi();
//		System.out.println(z.num);

//f.method1();
//f.method2();
//f.method3();

Fu f = new Zi();
System.out.println(f.num);
f.method4();

Zi z = new Zi();
z.method4();

//		Zi z = new Zi();
//		z.method1();
//		z.method2();
//		z.method3();
}
}


Object是所有对象的直接或间接的父类，该类中定义的是所有对象都具备的功能；
equals：比较两个对象是否“相等”；
toString：返回该对象的字符串表示；
hashCode:返回该对象的哈希值；

内部类：将一个类定义在另一个类的里面，对里面那个类就称为内部类，或内置类，嵌套类。

内部类访问规则：1.内部类可以直接访问外部类中的成员，包括私有；之所以可以直接访问外部类中的成员，是因为内部类中持有了一个外部类中的引用，格式：外部类名.this；2.外部类要访问内部类，必须建立内部类对象；

private私有，可以修饰成员变量和方法，但不能在方法体内；不可以修饰局部变量和类，修饰类只能修饰内部类；
class Outer
{
private int x = 3;

class Inner//内部类
{
//int x = 4;
void function()
{
//int x = 6;
System.out.println("innner :"+Outer.this.x);
}
}

/**/
void method()
{
Inner in = new Inner();
in.function();
}
}

class  InnerClassDemo
{
public static void main(String[] args)
{
Outer out = new Outer();
out.method();

//直接访问内部类中的成员。
//		Outer.Inner in = new Outer().new Inner();
//		in.function();
}
}
内部类访问格式：
① 当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中直接建立内部类对象：
格式： 外部类名.内部类名 变量名 = 外部类对象.内部类对象;
Outer.Inner in = new Outer(). new Inner();
②当内部类在成员位置上时，就可以被成员修饰符所修饰；
比如：private，讲内部类在外部类中进行封装；
static，内部类就具备了静态特性，被修饰后，内部类只能访问外部类中的静态成员；
在外部其他类中，如何直接访问静态内部类的非静态成员？new Outer.Inner().function();创建对象调用。
在外部其他类中，如果直接访问静态内部类的静态成员？Outer.Inner().function(); 直接调用。

注意：当内部类中定义了静态成员，该内部类必须是静态；
当外部类中的静态方法访问内部类时，内部类必须是静态；

class Outer
{
private static  int x = 3;

static class Inner//静态内部类
{
static void function()
{
System.out.println("innner :"+x);
}
}

static class Inner2
{
void show()
{
System.out.println("inner2 show");
}
}

public static void method()
{
//Inner.function();
new Inner2().show();
}

}

class  InnerClassDemo2
{
public static void main(String[] args)
{
Outer.method();
//Outer.Inner.function();
//new Outer.Inner().function();
//直接访问内部类中的成员。
//		Outer.Inner in = new Outer().new Inner();
//		in.function();
}
}


③当内部类定义在局部时，不可以被成员修饰符修饰，可以直接访问外部类中的成员，因为还有外部类中的引用，但是，不可以访问局部它所在局部中的变量，只能访问被final修饰的局部变量。
class Outer
{
int x = 3;

void method(final int a)
{
final int y = 4;
class Inner
{
void function()
{
System.out.println(y);
}
}

new Inner().function();

}
}

class  InnerClassDemo3
{
public static void main(String[] args)
{
Outer out = new Outer();
out.method(7);
out.method(8);
}

}
匿名内部类：内部类的简写格式；
定义匿名内部类的前提，内部类必须是继承一个类或实现了一个接口；
格式：new 父类或接口（）{子类定义的内容}
其实匿名内部类就是一个子类对象，可以理解为带内容的对象，匿名内部类最好不要超过3个。
内部类可以直接继承其他外部类。
abstract class AbsDemo
{
abstract void show();

}
class Outer
{
int x = 3;
public void function()
{
AbsDemo d = new AbsDemo()
{
int num = 9;
void show()
{
System.out.println("num==="+num);
}
void abc()
{
System.out.println("haha");
}
};

d.show();
d.abc();//编译失败;父类中没有定义过。
}
}
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 点击这里给我发消息
标签： 
相关文章推荐
新的分享
章节导航