Java面向对象 ----多态

java的第二部分面向对象————多态
4.1面向对象的第三个特征：
多态定义：
多态可以理解为某一类事物的多种存在形态。
例如：人可以分为男人女人
动物猫狗等
粮食大米小麦等
举例
例：动物中猫，狗。
猫这个对象对应的类型是猫类型
猫 x = new 猫();
同时猫也是动物中的一种，也可以把猫称为动物。
动物 y = new 猫();
动物是猫和狗具体事物中抽取出来的父类型。
父类型引用指向了子类对象。
从四个方面对多态进行学习：
1）多态的体现
父类的引用指向了自己的子类对象。 // Anmial a = new Cat();
或者称作是父类的引用接收自己的子类对象。

abstract class Anmial {public abstract void eat();
}class Cat extends Anmial
{public void eat() {System.out.println("吃鱼");}public void catchMouse() {System.out.println("逮老鼠");}
}
public class DuoTaiDemo {public static void main(String[] args) {// Anmial c = new Cat();//c.eat();funcation(new Cat());}public static void funcation(Anmial a) {a.eat();}}

2）多态的前提
(类与类之间要有关系)
1、需要存在继承或者实现关系
2、要有覆盖操作
3）多态的好处
多态的存在提高了程序的扩展性和后期可维护性。
4）多态的弊端：
提高了扩展性，但是只能使用父类的引用访问父类中的成员。
5）多态的应用
多态 - 转型
类型的提升：
引用数据类型（类类型）
Animal a = new Cat (); 类型提升也称为向上转型（转成父类型）
如果想调用猫的特有方法时怎么办呢？
强制将父类的引用转成子类类型。
Cat c= (Cat)a;
4.1.2多态中成员的特点：
成员函数：
多态中非静态成员函数的特点：编译时：要查看引用型变量所属的类中是否有所调用的方法。如果没有，编译会失败。
编译看左边，运行看右边。
在运行时：要查看对象所属的类中是否有所调用的成员。（若是子类中也有该方法那么就会将父类中的方法覆盖掉）

class Fu6 {public void method1() {System.out.println("Fu method1");}public void method2() {System.out.println("Fu method2");}}
class Zi6 extends Fu6
{public void method1() {System.out.println("zi method1");}public void method3() {System.out.println("zi method3");}
}public class DuoTaiDemo2 {public static void main(String[] args) {  Fu6 f = new Zi6();f.method1();   //此时  结果是：zi method1f.method2(); //   结果是：Fu method2    子类继承了父类的方法。// f.method3();   //此处编译会失败  原因引用变量所属的类中没有该方法。}}

在运行时：要查看对象所属的类中是否有所调用的成员。（若是子类中也有该方法那么就会将父类中的方法覆盖掉）

 Fu6 f = new Zi6();  //父类的引用指向了自己的子类对象   多态f.method1();  //   结果是： zi method1

多态中成员变量的特点：
无论编译还是运行只看引用变量所属的类。

class Fu6 {int num =6;public void method1() {System.out.println("Fu method1");}public void method2() {System.out.println("Fu method2");}}
class Zi6 extends Fu6
{int num =7;public void method1() {System.out.println("zi method1");}public void method3() {System.out.println("zi method3");}
}public class DuoTaiDemo2 {public static void main(String[] args) {Fu6 f = new Zi6();     System.out.println(f.num);  //  结果是 6Zi6  z =  new Zi6();System.out.println(z.num);   //   结果是  7

静态函数被调用时时只参考引用型变量所在的类即可。
4.2 内部类
将一个类定义在另一个类的里面，对里面那个类就称为内部类（内置类，嵌套类）。

class Outer{int x = 3;class Inner{int y =6;void show(){}}void  funcation(){}
}

访问规则：
内部类可以直接访问外部类中的成员，包括私有成员。
（原因是内部类中持有一个外部类的引用格式是外部类名.this）
而外部类要访问内部类中的成员必须要建立内部类的对象。


class Outer {private int x = 0;int y = 5;class Inner {void show(){funcation();   //内部类可以直接访问外部成员 包括私有的System.out.println("内部类" + x);}}void method() {Inner in = new Inner();   //外部类要访问内部类需要建立内部类对象in.show();}public void funcation() {System.out.println("外部类" + y);}
}public class InnerDemo {public static void main(String[] args) {Outer ot = new Outer();ot.method();  }        //  结果是：   外部类5内部类0
}

内部类的位置：
内部类定义在成员位置上可以被private static成员修饰符修饰。
被static修饰的内部类只能访问外部类中的静态成员。

class Outer {private static  int x = 0;static int y = 5;private static  class Inner    //   private static  成员修饰符修饰
{ int x =3;void show(){    int x = 6 ;funcation();    //   被static修饰的内部类只能访问外部类中的静态成员            System.out.println("内部类" +Outer.this. x); //  被static修饰的内部类只能访问外部类中的静态成员}   //  注意x处啥也不加默认走的是最近的x，6局部的;加上this走的是该类成员处本类对象的引用 3。加上Outer.this走                                                                                的是外部的成员变量。}void method() {Inner in = new Inner();in.show();}public static void funcation() {System.out.println("外部类" + y);}
}public class InnerDemo {public static void main(String[] args) {Outer ot = new Outer();ot.method();}}

直接访问内部类成员的格式（内部类不能私有和被静态修饰）
Outer.Inner in = new Outer().new Inner();
in.show();
内部类定义在局部位置上:
也可以直接访问外部类中的成员。
同时可以访问所在局部中的局部变量，但必须是被final修饰的。


class Outer {private static int x = 0;static int y = 5;public static void method() {final int x= 9;      class Inner {void show(){funcation();System.out.println("内部类" +x); // 局部变量处的局部变量必须被final修饰否则编译会失败（以免产生安全隐患）。                                                                                                                                                                  }Inner in = new Inner();      //在此处类的下面创建内部类对象，在类的上面Jvm编译会报错,认为没有类就new对象。in.show();}

4.2.1匿名内部类
匿名内部类是内部类的简化写法。（其实也就是没名字的内部类）
（思考匿名内部类没类名的话内部类的对象怎么创建呢？）
其实匿名内部类就是一个匿名子类对象。
**定义匿名内部类的前提是：
内部类必须继承或实现一个外部其他类或者接口。**
创建一个外部其他类的对象（当外部其他类是抽象类是要覆盖其方法的（抽象类不能被直接创建对象））
匿名内部类的格式： new 外部其他类名或者接口（）{ 定义子类的内容（覆盖类或者接口的代码） }

abstract class AbsDemo
{abstract void show();
}
class OuterDemo {private int x = 5;int y = 3;void funcation() {new AbsDemo()                 ////new Inner().show();  这部分其实就是匿名内部类对象{void show (){method();System.out.println("show:::"+x);}}.show();
}public void method()                                {System.out.println("外部类" + y);}
}public class NIMingDemo {public static void main(String[] args) {OuterDemo ot = new OuterDemo();ot.funcation() ;}}

匿名内部类的演化进程就是下面的内部类继承一个外部其他类缩写。

/*class Inner extends AbsDemo{public void show() {method();System.out.println("show::" + x);}
*/

记住：其实匿名内部类就是一个匿名子类对象。而且这个对象有点胖，一个带内容的子类对象。
匿名内部类可以用父类名引用型变量 = new 父类的子类对象；匿名内部类的多态。

abstract class AbsDemo {abstract void show();
}
class  Outer{void funcation() {//new Inner().show();AbsDemo a = new AbsDemo(){void show (){method();System.out.println("show:::"+x);}void jjK(){  System.out.println("hahh");}};   // 记住此处是个分号         AbsDemo  a   =   new  Inner();  多态a.show();//a.jjk();     //此处编译是失败的，多态 父类中没有此方法编译失败。}

匿名内部类的应用：

interface Inter
{void mehod();
}
class Test
{   //  补足代码根据下面的语句public static Inter funcation(){return  new Inter(){public void method(){System.out.println("method run");}};}
}
class TestDemo
{public static void mian(String[] args){Test.funcation().method();}}

匿名内部类作为参数传递：

interface Inter
{void method();
}
public class InnerDemo2 {public static void main(String[] args){show(new Inter(){public void  method(){System.out.println("method run");}});             //直接调用 静态方法 show (主函数是静态的)}public static void show (Inter in){in.method();}  }

Java面向对象 ----多态相关推荐

7.Java面向对象-多态
7.Java面向对象-多态一.多态的概述及其代码体现 A:多态概述某一个事物,在不同时刻表现出来的不同状态.举例: Cat c=new Cat();Animal a=new Cat();猫可以是猫的 ...
java面向对象多态特性
一.多态的概念多态是继封装,继承之后,面向对象的三大特性. 现实事物经常会体现出多种形态,如学生,学生是人的一种,则一个具体的张三同学既是学生也是人,即出现两种形态. java作为面向对象的语言,同 ...
java 面向对象多态_乐字节Java面向对象三大特性以及Java多态
以上就是本次学习的6大任务.我们依次来看. 1 Object类 Object类是所有Java类的根基类. 如果在类的声明中未使用extends关键字指明其基类,则默认基类为Object类. cla ...
java面向对象多态和内部类的深入学习
一.多态 1.类的多态需求: 需求:老师骑着自行车上班分析:老师类.自行车类需求升级/迭代:自行车->小汽车步骤: 1.创建Car类,编写start.stop 2.在原有Teacher类 ...
Java学习笔记二十五:Java面向对象的三大特性之多态
Java面向对象的三大特性之多态一:什么是多态: 多态是同一个行为具有多个不同表现形式或形态的能力. 多态就是同一个接口,使用不同的实例而执行不同操作. 多态性是对象多种表现形式的体现. 现实中,比 ...
12 Java面向对象之多态
JavaSE 基础之十二 12 Java面向对象之多态 ① 多态的概念及分类多态的概念:对象的多种表现形式和能力多态的分类 1. 静态多态:在编译期间,程序就能决定调用哪个方法.方法的重载就表现出 ...
Java面向对象（二）面向对象的特征 --- 封装、继承、多态
面向对象的特征:封装.继承.多态.(抽象) 一.封装体现形式: 函数 --- 提高代码的复用性. 属性的私有化 --- 将属性设为私有,通过提供对外的访问方法来间接操作对象属性,可以再方法内对属性做 ...
java 多态_Java面向对象 —— 多态
前两天已经相继介绍了Java面向对象的三大特性之中的封装.继承,所以今天就介绍Java面向对象的三大特性的最后一项,多态~ 首先讲一下什么是多态,以及多态需要注意的细节什么是多态:一个对象具备多种形 ...
Java 面向对象：多态的理解
Java 面向对象:多态的理解一.多态的定义一个对象的实际类型是确定的,但可以指向引用对象的类型可以有很多(父类,有关系的类) 操作符的多态 +可以作为算数运算,也可以作为字符串连接类的多态父 ...

Java面向对象 ----多态

Java面向对象 ----多态相关推荐

最新文章

热门文章