java面向对象多态和内部类的深入学习
2024-06-01 22:31:19
一.多态
1.类的多态
需求：
需求：老师骑着自行车上班
分析：老师类、自行车类
需求升级/迭代：自行车->小汽车
步骤：
1.创建Car类，编写start、stop
2.在原有Teacher类的基础上编写open、close
注意：违反了OCP原则
OCP - 开闭原则：
O - open ：在需求升级时，对于创建类是欢迎的
C - close：在需求升级时，改变原有代码是拒绝的
注意：需求升级时，尽量不要改变以前的类，否则容易出bug
需求升级/迭代：自行车->小汽车->飞机
步骤：创建Plane类继承Vehicle
代码解析：
package com.dream.test01;public class Test01 {public static void main(String[] args) {Teacher t = new Teacher();//类的多态：子类对象指向父类引用//父类引用中存储的是子类对象在堆中的地址Teacher t = new Teacher();Vehicle v1 = new Bick();Vehicle v2 = new Car();Vehicle v3 = new Plane();t.open(v1);System.out.println("欣赏沿途的风景...");t.close(v1);System.out.println("---------------");t.open(v2);System.out.println("认真开车...");t.close(v2);System.out.println("---------------");t.open(v3);System.out.println("欣赏沿途的风景...");t.close(v3);}
}
package com.dream.test01;public abstract class Vehicle {public abstract void start();public abstract void stop();
}
package com.dream.test01;public class Teacher {public void open(Vehicle v){v.start();}public void close(Vehicle v){v.stop();}}
package com.dream.test01;public class Bick extends Vehicle{@Overridepublic void start(){System.out.println("自行车：握好扶手，踩下脚踏板");}@Overridepublic void stop(){System.out.println("自行车：捏手刹~~~");}
}
package com.dream.test01;public class Car extends Vehicle{@Overridepublic void start(){System.out.println("小汽车：一键启动，踩下油门");}@Overridepublic void stop(){System.out.println("小汽车：踩刹车，熄火~~");}}
package com.dream.test01;public class Plane extends Vehicle{@Overridepublic void start() {System.out.println("飞机：一键启动，加油门，拉机翼~~~");}@Overridepublic void stop() {System.out.println("飞机：跳伞~~~");}}
输出：
/*
自行车：握好扶手，踩下脚踏板
欣赏沿途的风景...
自行车：捏手刹~~~
---------------
小汽车：打火启动
认真开车...
小汽车：踩刹车
---------------
飞机：一键启动，加油门，拉机翼~~~
欣赏沿途的风景...
飞机：跳伞~~~
*/
2.接口的多态
需求：
鼠标、硬盘连接电脑
代码实现：
package com.study.test03;public class Test01 {public static void main(String[] args) {//接口的多态：实现类的对象指向接口的引用//接口的引用中存放的是实现类对象在堆中开辟空间的地址Computer computer = new Computer();IUSB usb1 = new Mouse();computer.connection(usb1);System.out.println("--------------------");IUSB usb2 = new Disk();computer.connection(usb2);System.out.println("--------------------");IUSB usb3 = new Keyboard();computer.connection(usb3);System.out.println("--------------------");}
}
//定义USB接口
package com.study.test03;public interface IUSB {public void use();
}
//定义Mouse，Disk，Keyboar实现接口方法
package com.study.test03;public class Mouse implements IUSB{@Overridepublic void use() {System.out.println("鼠标：点来点去"); }}
package com.study.test03;public class Disk implements IUSB{@Overridepublic void use() {System.out.println("硬盘：存东西");}}
package com.study.test03;public class Keyboard implements IUSB{@Overridepublic void use() {System.out.println("键盘：打字");}}
//定义接口使用者Computer
package com.study.test03;public class Computer {public void connection(IUSB usb) {System.out.println("连接成功！");usb.use();}}输出：
/*
连接成功！
鼠标：点来点去
--------------------
连接成功！
硬盘：存东西
--------------------
连接成功！
键盘：打字
--------------------
*/
二.对象转型
1.向上转型
子类类型 转 父类类型
可以调用父类非私有化属性
可以调用父类非私有化方法
可以调用子类重写父类的方法
不可以调用子类属性和方法
注意：向上转型就是多态
多态的缺点：不可以调用子类自己的属性和方法
代码实现：
package com.dream.test03;public class Test01 {public static void main(String[] args) {A a = new B();System.out.println(a.aAtrr);a.aMethod();a.method();}}
package com.dream.test03;public class A {String aAtrr = "父类属性";public void aMethod(){System.out.println("父类方法");}public void method(){System.out.println("父类方法");}}
package com.dream.test03;public class B extends A{String bAtrr = "子类属性";public void bMethod(){System.out.println("子类方法");}@Overridepublic void method(){System.out.println("子类重写父类的方法");}}
2.向上转型
父类类型 转 子类类型
注意：
1.向下转型转不好就会出现ClassCastException - 类型转换异常
2.向下转型一定要使用instanceof判断
代码实现：
package com.dream.test04;public class Test01 {public static void main(String[] args) {Animal an = new Dog();//向上转型if(an instanceof Cat){//判断an引用指向的对象是否是Cat类型Cat cat = (Cat) an;//向下转型cat.shout();}else if(an instanceof Dog){//判断an引用指向的对象是否是Dog类型Dog dog = (Dog) an;//向下转型dog.eat();}}}
package com.dream.test04;public class Animal {}
package com.dream.test04;public class Cat extends Animal{public void shout(){System.out.println("喵喵喵~~~");}
}
package com.dream.test04;public class Dog extends Animal{public void eat(){System.out.println("啃骨头~~~");}
}
三.内部类
1.成员内部类
特点：
可以调用外部类中所有的属性
代码实现：
package com.dream.outter_inner_01;import com.dream.outter_inner_01.Outter.Inner;public class Test01 {public static void main(String[] args) {//创建成员内部类对象Inner inner = new Outter().new Inner();//调用方法inner.method();}
}package com.dream.outter_inner_01;//外部类
public class Outter {private String str1 = "aaa";String str2 = "bbb";protected String str3 = "ccc";public String str4 = "ddd";final String str5 = "eee";static String str6 = "fff";//成员内部类class Inner{private String str1 = "成员内部里的属性~~~";public void method(){System.out.println("成员内部类里的方法");System.out.println(this.str1);System.out.println(Outter.this.str1);//调用外部类的属性System.out.println(str2);//Outter.this.str2System.out.println(str3);//Outter.this.str3System.out.println(str4);//Outter.this.str4System.out.println(str5);//Outter.this.str5System.out.println(str6);//Outter.str6}}
}
2.静态内部类
特点：
只能到调用外部类的静态属性
代码实现：
package com.dream.outter_inner_02;import com.dream.outter_inner_02.Outter.Inner;public class Test01 {public static void main(String[] args) {//创建静态内部类对象(不用创建外部类对象)Inner inner = new Outter.Inner();//调用方法inner.method();}
}package com.dream.outter_inner_02;//外部类
public class Outter {private String str1 = "aaa";String str2 = "bbb";protected String str3 = "ccc";public String str4 = "ddd";final String str5 = "eee";static String str6 = "fff";//静态内部类static class Inner{public void method(){System.out.println("静态内部类里的方法");//静态内部类不能调用外部类的成员变量
// System.out.println(str1);
// System.out.println(str2);
// System.out.println(str3);
// System.out.println(str4);
// System.out.println(str5);System.out.println(str6);//Outter.str6}}
}
3.接口内部类
特点：
接口内部类底层就是静态内部类
代码实现：
package com.dream.outter_inner_03;import com.dream.outter_inner_03.Outter.Inner;public class Test01 {public static void main(String[] args) {//创建接口内部类对象Inner inner = new Outter.Inner();//调用方法inner.method();}
}package com.dream.outter_inner_03;//接口
public interface Outter {//接口内部类 默认添加public staticclass Inner{public void method(){System.out.println("接口内部类里的方法");}}
}4.局部内部类
代码实现：
package com.dream.outter_inner_04;public class Test01 {public static void main(String[] args) {//创建外部类的对象Outter outter = new Outter();//调用方法outter.function();}
}package com.dream.outter_inner_04;//外部类
public class Outter {public void function(){int i = 100;//局部内部类调用方法中的局部变量，JDK1.8中属性默认为final常量/*原因：和内部类Inner的生命周期相关。final修饰的局部变量是常量，放在常量池中，不会随着function()方法的使用完毕后一起被回收，保证在内部类Inner的方法method()调用该局部变量i时仍然存在可以被调用*///局部内部类class Inner{public void method(){System.out.println("局部内部类里的方法" + i);}}//创建局部内部类的对象Inner inner = new Inner();//调用方法inner.method();}
}5.匿名内部类
抽象类中的匿名内部类
代码实现：
package com.dream.outter_inner_06;public class Test01 {public static void main(String[] args) {//1.创建匿名子类，继承A，重写method//2.创建匿名子类对象，赋值给父类的引用A a = new A() {@Overridepublic void method() {}}; }
}package com.dream.outter_inner_06;public abstract class A {public abstract void method();}接口中的匿名内部类
代码实现：
package com.dream.outter_inner_06;public class Test02 {public static void main(String[] args) {//1.创建匿名实现类，实现I1中的method//2.创建匿名实现类的对象，指向接口的引用I1 i1 = new I1() {@Overridepublic void method() {}};}}package com.dream.outter_inner_06;public interface I1 {public void method();
}6.内部类的应用场景总结
内部类的应用场景1：
如果一个类的对象只在另外一个类中使用，就可以考虑把该类变成成员内部类或者静态内部类;
如果内部类要用到外部类的所有属性就把该类变成成员内部类;
如果内部类只用到外部类的静态属性就把给类变成静态内部类;
内部类的应用场景2：
如果一个类的对象只在另外一个类的方法中使用，就可以考虑把该类变成局部内部类，一般不使用这种设计思想;
内部类的应用场景3：
如果一个类的对象只在接口中使用，就可以考虑把该类变成接口内部类，一般不使用这种设计思想;
内部类的应用场景4：
抽象类子类的对象或者是接口实现类对象只使用到一次，就可以考虑使用匿名内部类;
java面向对象多态和内部类的深入学习相关推荐
- 7.Java面向对象-多态
7.Java面向对象-多态 一.多态的概述及其代码体现 A:多态概述某一个事物,在不同时刻表现出来的不同状态.举例: Cat c=new Cat();Animal a=new Cat();猫可以是猫的 ...
- Java面向对象 ----多态
java的第二部分 面向对象----多态 4.1面向对象的第三个特征: 多态定义: 多态可以理解为某一类事物的多种存在形态. 例如: 人 可以分为 男人 女人 动物 猫 狗 等 粮食 大米 小麦等 举 ...
- java面向对象多态特性
一.多态的概念 多态是继封装,继承之后,面向对象的三大特性. 现实事物经常会体现出多种形态,如学生,学生是人的一种,则一个具体的张三同学既是学生也是人,即出现两种形态. java作为面向对象的语言,同 ...
- java 面向对象多态_乐字节Java面向对象三大特性以及Java多态
以上就是本次学习的6大任务.我们依次来看. 1 Object类 Object类是所有Java类的根基类. 如果在类的声明中未使用extends关键字指明其基类,则默认基类为Object类. cla ...
- 面试轻松讲清楚 Java 面向对象的问题与知识（类与对象，封装，继承，多态，接口，内部类...）
写在最前面 这个项目是从20年末就立好的 flag,经过几年的学习,回过头再去看很多知识点又有新的理解.所以趁着找实习的准备,结合以前的学习储备,创建一个主要针对应届生和初学者的 Java 开源知识项 ...
- 如何讲清楚 Java 面向对象的问题与知识？（类与对象，封装，继承，多态，接口，内部类...）
二 Java面向对象 类和对象 1.1 什么是面向过程?什么又是面向对象? 面向过程--步骤化 面向过程就是分析出实现需求所需要的步骤,通过函数(方法)一步一步实现这些步骤,接着依次调用即可 面向对象 ...
- Java学习笔记二十五:Java面向对象的三大特性之多态
Java面向对象的三大特性之多态 一:什么是多态: 多态是同一个行为具有多个不同表现形式或形态的能力. 多态就是同一个接口,使用不同的实例而执行不同操作. 多态性是对象多种表现形式的体现. 现实中,比 ...
- day8 Java学习（面向对象.多态接口）
面向对象 多态: 概述:事物存在的多种形态. 多态前提: *要有继承关系 *要有方法重写 *要有父类引用指向子类对象. 成员变量访问: 编译看左边(父类),运行左边(父类) ...
- Java面向对象基础学习笔记（构造、重载、继承、多态、抽象类、接口、模块）
Java面向对象编程包含哪些内容? 怎么理解面向对象编程? 现实生活中,我们定义了"人"的抽象概念,这就是类class,生活中的每一个具体的人就是实例instance. class ...
最新文章
- 如何利用离散Hopfield神经网络进行高校科研能力评价(1)
- 字符串（string类）
- ndk use of undeclared identifier #39malloc#39
- 用sniffer技术盗取电话银行密码
- python redis模块常用_python-Redis模块常用的方法汇总
- 单链表的合并算法_图解算法：单链表两两反转 | 眼睛会了手就会系列
- php苹果推送消息,php推送消息到IOS
- 电脑软件从通过运行开启（耍帅必会）
- c语言回文串试题,最短回文串 -- C语言
- J2EE进阶之自定义标签，JSTL标签，国际化 十四
- java 调用nc查询引擎_用友NC系统查询引擎应用心得
- Telemetry原理
- 大数据时代最全的医学公共数据库合集整理
- PC微信 HOOK 接口 (版本：3.6.0.18)
- 二分法解一元三次方程c语言,用二分法求一元三次方程的C++程序
- web前端应对4k屏幕_应对复杂的屏幕
- 基于C++的数据结构-1
- 把程序作为人生，把人生当作程序
- 半导体器件相关专业词汇积累ing
- 从键盘上输入一个整数 N，输出 1~N 之间能被 7 整除的整数的个数，以及这些能被 7 整 除的数的和