面向对象的三大特征:
1.封装 （将一类属性封装起来，并提供set()和get()方法给其他对象设置和获取值。或者是将一个运算方法封装起来，其他对象需要此种做运算时，给此对象调用）
2.继承 （继承关系通过extends关键字体现）
3.多态 （父类的引用指向子类的对象，或者接口的引用类型变量指向接口实现类的对象）
1、多态的含义
父类的引用指向子类的对象，或者接口的引用类型变量指向接口实现类的对象
2、多态的应用
1.多态应用于形式参数的时候,可以接收更多类型的数据.
2.多态用于返回值时,可以返回更多类型的数据.
3、多态的好处
提高了代码的拓展性.
4、多态的弊端
虽然提高了扩展性，但是只能使用父类引用指向父类成员。
5、多态的前提
类与类之间有关系，继承或者实现
6、多态体现
1：父类引用变量指向了子类的对象
2：父类引用也可以接受自己的子类对象
7、类型转换场景的问题
java.lang.ClassCaseException.类型转换失败
8、附录
如果需要访问子类特有的成员,那么需要进行强制类型转换 1、基本数据类型转换:
小数据类型------>大数据类型 自动转换
大数据类型------>转小数据类型 强制类型转换 2、引用类型转换：
小数据类型------->大数据类型 自动转换
大数据类型------->转小数据类型 强制类型转换
9、实现关系下的多态
接口的引用类型变量指向接口实现类的对象
格式：
接口 变量 = new 接口实现类的对象
例子：
interface Dao { //接口的方法全部都是非静态的方法
public void add();
public void delete();
}
//接口的实现类
class UserDao implements Dao{
public void add(){
System.out.println("添加员工!!!");
}
public void delete(){
System.out.println("删除员工");
}
}
class Demo2 {
public static void main(String[] args) {
//实现关系下的多态
Dao d=new UserDao(); //接口的引用类型变量指向接口的实现类的对象
d.add();
d.delete();
}
}
10、实例
例子1：
/*
1：Father类
1：非静态成员变量x
2：静态成员变量y
3：非静态方法eat,方法体输出父类信息
4：静态方法speak();方法体输出父类信息
2：Son类
1：非静态成员变量x
2：静态成员变量y
3：非静态方法eat，方法体输出子类信息
4：静态方法speak();方法体输出子类信息
*/
class Father {
int x = 1;
static int y = 2; void eat() {
System.out.println("开吃");
}
static void speak() {
System.out.println("小头爸爸");
}
} class Son extends Father {
int x = 3;
static int y = 4; void eat() {
System.out.println("大头儿子很能吃");
}
static void speak() {
System.out.println("大头儿子。");
}
} class Demo10 {
public static void main(String[] args) {
Father f = new Son(); // 父类引用指向了子类对象。
System.out.println(f.x); //返回结果：1
System.out.println(f.y); //返回结果：2 f.eat(); // 输出的是子类的方法
f.speak(); // 输出的是父类的方法
}
}
解析：子类（Son）继承父类（Father）
1：创建Father f=new Son();
1：这就是父类引用指向了子类对象。
2：问f.x=?（非静态）
3：问f.y=?（静态）
4：问f.eat()输出的是子类还是父类信息？（非静态）
5：问f.speak()输出的是子类还是父类信息？（静态）
总结：
1：当父类和子类具有相同的非静态成员变量，那么在多态下访问的是父类的成员变量
2：当父类和子类具有相同的静态成员变量，那么在多态下访问的是父类的静态成员变量 所以：父类和子类有相同的成员变量，多态下访问的都是父类的成员变量。
3：当父类和子类具有相同的非静态方法（就是子类重写父类方法），多态下访问的是子类的成员方法。
4：当父类和子类具有相同的静态方法（就是子类重写父类静态方法），多态下访问的是父类的静态方法。
例子2：
//动物类
abstract class Animal{
String name;
public Animal(String name){
this.name=name;
} public abstract void run(); //抽象方法
}
//老鼠类
class Mouse extends Animal{
public Mouse(String name){ //调用父类构造器，目的：获取成员变量name中的值
super(name);
}
public void run(){ //重写父类的抽象方法
System.out.println(name+"四条腿慢慢走");
} public void dig(){//Mouse子类特有的方法
System.out.println(name+"老打洞..."); }
}
//鱼类
class Fish extends Animal{
public Fish(String name){
super(name);
}
public void run(){ //重写父类的抽象方法
System.out.println(name+"摇着尾巴游啊游...");
}
public void bubble(){ //Fish子类特有的方法
System.out.println(name+"吹泡泡....");
}
} class Demo6 {
public static void main(String[] args) {
Animal a=new Mouse("米老鼠");//多态,父类的引用指向子类的对象
a.run();
//a.dig(); //报错 Mouse m=(Mouse)a;//强制类型转换
m.dig(); //如果直接用a.dig()的话，会报错，因为是多态(父类中没有dig()方法)，所以要强制转换类型 Animal a1=new Fish("金枪鱼");
Fish f=(Fish)a1;
print(f);
} //需求,定义一个函数可以接收任意类型的动物对象,在函数的内部要调用到动物特有的方法
//instanceof
public static void print(Animal a){//Animal a=new Fish();
if(a instanceof Fish){
Fish f=(Fish)a;
f.bubble();
}else if(a instanceof Mouse){
Mouse m=(Mouse)a;
m.dig();
}else{
System.out.println("输入错误");
}
}
}
//形状类
abstract class MyShape{//抽象类
public abstract void getLength(); //抽象方法
public abstract void getArea(); //抽象方法
}
//圆形
class Circle extends MyShape{
public final static double PI=3.14; //常量
double r;
public Circle(double r){
this.r=r;
} public void getLength(){
System.out.println("这是圆形的周长"+2*PI*r);
}
public void getArea(){
System.out.println("这是圆形的面积"+PI*r*r); }
}
//矩形
class Rect extends MyShape{
int width;
int height; public Rect(int width,int height){
this.width=width;
this.height=height;
}
public void getLength(){
System.out.println("这是矩形的周长"+2*(width+height));
}
public void getArea(){
System.out.println("这是矩形的面积"+width*height);
}
public void t(){
System.out.println("来咬我啊!!!");
}
} class Demo5 {
public static void main(String[] args) {
MyShape mp=new Circle(3.0);//多态,父类的引用指向了子类的对象
mp.getLength();
mp.getArea();
47 //方法2
Circle c = new Circle(3.0);
Rect r = new Rect(5,8);
MyShape m = new Rect(8,3);
//m.t(); //报错，此处需要强制类型转换
print(r);
print(c);//new Circle(3.0)
} //需求1.定义一个函数可以接收任意类型的对象,并且打印图形的面积与周长
public static void print(MyShape s){//相当于：MyShape s=new Circle(3.0)
s.getLength();
s.getArea();
MyShape m = getShape(1);
} //需求2:定义一个函数可以返回任意类型的图形对象.
public static MyShape getShape(int i){ if(i == 1){
return new Circle(2.0);
}else if(i == 0){
return new Rect(6,9);
}else{
return null;
}
}
}
|
原创作者：DSHORE 作者主页：http://www.cnblogs.com/dshore123/ 原文出自：http://www.cnblogs.com/dshore123/p/8891998.html 欢迎转载，转载务必说明出处。（如果本文对您有帮助，可以点击一下右下角的 推荐，或评论，谢谢！） |