目录
前言:
面向对象的三大特征:封装、继承、多态。
一、面向对象三大特征之一:封装
1.概述:
封装是把过程和数据包围起来，对数据的访问只能通过已定义的接口。面向对象计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治、封装的对象，这些对象通过一个受保护的接口访问其他对象。封装是一种信息隐藏技术，在java中通过关键字private，protected和public实现封装。什么是封装？封装把对象的所有组成部分组合在一起，封装定义程序如何引用对象的数据，封装实际上使用方法将类的数据隐藏起来，控制用户对类的修改和访问数据的程度。 适当的封装可以让程式码更容易理解和维护，也加强了程式码的安全性。
封装：告诉我们，如何正确设计对象的属性和方法。
封装的原则：对象代表什么，就得封装对应的数据，并提供数据对应得行为。
private：修饰的成员只能在当前类中访问。
2.例子:
public class Show{
public static void show(String str){
System.out.println(str);
}
}上面就是对 System.out.println();的封装。
调用的时候 ：
public class Use{
public static void main(String[] args){
Show.show("封装")；
}
}这样用的时候就不用使：System.out.println("封装")；
二、面向对象三大特征之二:继承
1.什么是继承?
java中提供一个关键字extends，用这个关键字，我们可以让一个类和另一个类建立起父子关系。
public class Student extends people{}
Student称为子类(派生类)，people称为父类(基类或超类)。
父类（super）、子类（this）
作用: 当子类继承父类后，就可以直接使用父类公共的属性和方法了。
2.继承规范:
①子类们相同特征(共性属性，共性方法)放在父类中定义。
②子类独有的属性和行为应该定义在子类自己里面。
3.继承的特点：
①子类有自己的构造器，不能继承父类的构造器 ②子类是否可以继承父类的私有成员（可以继承父类的私有成员，只是不能直接访问！ ）
③子类是否可以继承父类的静态成员(不是继承，是共享的父类的) ④java只能继承一个父类，不支持多继承，不过支持多层继承。 多层继承： A继承B，B继承C；
⑤object ：object是祖宗类
4.在子类中给访问成员（成员变量、成员方法）满足：就近原则(局域对象<子类对象<父类对象)
①先子类局部范围找。
②然后子类成员范围找。
③然后父类成员范围找，如果父类范围还没有找到则报错。
5.如果子父类中，出现了重名的成员，会优先使用子类的，此时如果一定要在子类中使用父类的怎么办？
①可以通过super关键字，指定访问父类的成员。
格式:super.父类成员变量/父类成员方法
②可以通过this关键字，指定访问子类的成员。
格式:this.子类成员变量/子类成员方法
6.继承后:方法重写
在继承体系中，子类出现了和父类中一摸一样的方法声明，我们就称子类这个方法是重写的方法。
7.方法重写的应用场景
①当子类需要父类的功能，但父类的该功能不完全满足自己的需求时。
②子类可以重写父类中的方法。
8.@Override重写注解：
放在重写后的方法上，作为重写是否正确的校验注解。
作用：
1.这个方法必须是正确重写的；
2.提高代码的可读性,代码优雅。
注意:
①重写方法的名词称、形参列表必须与被重写方法的名称和参数列表一致。
②私有方法不能被重写。
③子类重写父类方法时，访问权限必须大于或者等于父类。
④子类不能重写父类的静态方法，如果重写会报错。
9.方法重写案例:
旧手机的功能只能是基本的打电话，发信息；
新手机的功能需要能够在基本的打电话下支持视频通话。基本的发信息下支持发送语音和图片。
main类:
public class extends_Test {
public static void main(String[] args) {
//方法重写
newphone nw = new newphone();
nw.call();
nw.sending();
}
}新手机类(子类):
/*
新手机:子类
*/
class newphone extends phone{
//重写的方法
@Override//1.这个方法必须是正确重写的；2.提高代码的可读性,代码优雅。
public void call(){
super.call();//先用父类的基本功能
System.out.println("开始视频通话");
}
//重写的方法
@Override
public void sending(){
super.sending();//先用父类的基本功能
System.out.println("发送有趣的图片~~");
}
}旧手机类(父类):
/*
旧手机:父类
*/
class phone{
public void call(){
System.out.println("打电话");
}
public void sending(){
System.out.println("发短信");
}
}10.继承后:子类继承父类后构造器的特点:
子类所有构造器都会先访问父类构造器，再调用自己的构造器，初始化父类的数据。
为什么?
①子类在初始化的时候，有可能会使用到父类中的数据，如果父类没有完成初始化，子类将无法使用父类的数据。
②子类初始化之前，一定要调用父类构造器先完成父类数据空间的初始化。
怎么调用父类构造器？
子类构造器的第一行语句默认都是:super(),不写也存在。
11.继承后:子类构造器访问父类有参构造器？
super调用父类有参构造器的作用:
初始化继承自父类的数据；
如果父类中没有无参数构造器，只有有参构造器，会出现什么现象呢？
会报错，因为子类默认是调用父类无参构造器的。
如何解决？
子类构造器中可以书写super(...)，手动调用父类的有参数构造器。
12.代码演示:
猫类(子类):
public class cat extends dog {
public cat(){
System.out.println("子类cat无参数构造器被执行~~");
}
public cat(String name){
System.out.println("子类cat有参数构造器被执行~~");
}
}狗类(父类):
public class dog {
public dog(){
System.out.println("父类dog无参数构造器被执行~~");
}
}main类:
public class test1 {
public static void main(String[] args) {
//继承后子类构造器的特点
cat c1 = new cat();
System.out.println(c1);
System.out.println("----------");
cat c2 = new cat("金毛");
System.out.println(c2);
}
}13.this和super小结
this:代表本类对象的引用；
super：代表父类存储空间的标识。
-
this()和super（）必须要在第一行，所以一个构造器中不能共存this()和super();
-
this :访问子类当前对象的成员
-
super :在子类方法中指定访问父类的成员
-
this(...) :访问本类兄弟构造器
-
super(...) : 在本类构造器中指定访问父类的构造器
14.代码演示:
动物类(父类):
public abstract class Animal {
public String name = "动物名";
public void eat() {
System.out.println("动物要吃东西!");
}
public static String location = "长隆动物园";
public abstract void run();
}老虎类(子类):
public class Tiger extends Animal {
public static boolean location;
String name = "老虎名";
public void showName(){
String name = "局部名";
System.out.println(name);
System.out.println(this.name);
System.out.println(super.name);
super.eat();
this.eat();
}
@Override // 1、重写校验注解，加上之后，这个方法必须是正确重写的，这样更安全 2、提高代码的可读性
/**1、重写的名字和形参列表必须与被重写的方法一样
* 2、私有方法不能被重写
* 3、子类重写父类方法时，访问权限必须大于或者等于父类（ 访问权限：privase < 不写 < protected < public）
* 4、静态方法不能被子类重写
*/
public void eat(){
super.eat();//方法重写，重写父类
System.out.println("老虎在吃东西");
}
@Override
public void run() {
}
}实现类:
//extends :子类继承父类 让一个类与另一个类建立父子关系，用于提高代码复用性（子类extends 父类）
//父类（super）、子类（this）
public class extends_Demo4 {
/** 继承的特点：
* 1、子类有自己的构造器，不能继承父类的构造器
* 2、子类是否可以继承父类的私有成员（可以继承父类的私有成员，只是不能直接访问！ ）
* 3、子类是否可以继承父类的静态成员(不是继承，是共享的父类的)
* 4、java只能继承一个父类，不支持多继承，不过支持多层继承。 多层继承： A继承B，B继承C；
* 5、object ：object是祖宗类
* 在子类中给访问成员（成员变量、成员方法）满足：就近原则(局域对象<子类对象<父类对象)
*/
//子类所有构造器都会先访问父类构造器，再调用自己的构造器，初始化父类的数据
/**
* this()和super（）必须要在第一行，所以一个构造器中不能共存this()和super();
* this :访问子类当前对象的成员
* super :在子类方法中指定访问父类的成员
* this(...) :访问本类兄弟构造器
* super(...) : 在本类构造器中指定访问父类的构造器
*/
public static void main(String[] args) {
Tiger t = new Tiger();
t.eat();
System.out.println(Tiger.location);
t.showName();
}
}
三、面向对象三大特征之三:多态
1.概述:
同类型的对象执行同一个行为，会表现出不同的行为特征。
2.多态的常见形式:
父类类型 对象名称 = new 子类构造器；
接口 对象名称 = new 实现类构造器；
3.代码演示:
动物类:
public abstract class Animal {
public String name = "动物名";
public void eat() {
System.out.println("动物要吃东西!");
}
public static String location = "长隆动物园";
public abstract void run();
}实现类:
public class polymorphic_Demo {
public static void main(String[] args) {
Animal a = new Animal() {//父类类型 对象名称 = new 子类构造器；
@Override
public void run() {
System.out.println("????跑得很快~~");
}
};
a.run();//编译看左边，运行看右边
}4.多态成员访问特点：
-
方法调用：编译看左边，运行看右边
-
变量调用：编译看左边，运行看左边（多态侧重行为多态）
5.多态的前提：
①有继承/实现关系；
②有父类引用指向子类对象；
③有方法重写；
6.多态的优势：
①在多态的形式下，右边对象可以实现解耦合，便于扩展和维护；
②定义方法的时候，使父类型作为参数，该方法可以接收这父类的一切子类对象，体现出多态的扩展性与便利；
③多态下不能访问子类的独有功能；
7.多态下引用数据类型的类型转换
-
自动类型转换（从子到父）:子类对象赋值给父类类型的变量指向；
-
强制类型转换（从父到子）：子类 对象变量 = （子类）父类类型的变量；
-
作用：解决多态下的劣势，实现调用子类独有的功能。
-
有继承或实现关系编译阶段可以强制转换，但如果转型后的类型和对象的真实类型不是同一种类型，那么在转换的时候就会出现异常:ClassCastException
-
-
Java建议强制转换前使用instanceof判断当前对象的真实类型，再进行强制转换；
-
变量名 instanceof 真实类型：用于判断关键字左边的变量指向的对象的真实类型，是否是右边的类型或者是其子类类型，是则返回true；
-
9.案例:
需求:
①使用面向对象编程模拟:设计一个电脑对象，可以安装2个USB设备。
②鼠标:被安装时可以完成接入、调用点击功能、拔出功能。
③键盘:被安装时可以完成接入、调用点击功能、拔出功能。
分析:
①定义一个USB的接口(申明USB设备的规范必须是:可以接入和拔出)。
②提供2个USB实现类代表鼠标和键盘，让其实现USB接口，并分别定义独有功能。
③创建电脑对象，创建2个USB实现类对象，分别安装到电脑中并触发功能的执行。
USB接口规范类:
/**
* USB接口 == 规范
*/
public interface USB {
//接入、拔出
void connect();
void unconnect();
}键盘实现类:
/**
* 实现类
*/
public class keyBoard implements USB{
private String name;
public keyBoard(String name) {
this.name = name;
}
@Override
public void connect() {
System.out.println(name+"成功连接电脑");
}
@Override
public void unconnect() {
System.out.println(name+"成功拔出电脑");
}
/**
* 独有功能
*/
public void keyDown(){
System.out.println(name+"敲击了：来了，老弟~~");
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}鼠标实现类:
/**
* 实现类
*/
public class Mouse implements USB {
private String name;
public Mouse(String name) {
this.name = name;
}
@Override
public void connect() {
System.out.println(name + "成功连接电脑");
}
@Override
public void unconnect() {
System.out.println(name + "成功拔出电脑");
}
/**
* 独有功能
*/
public void duClick() {
System.out.println(name + "双击点亮：小红心~~");
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}电脑实现类:
public class computer {
private String name;
public computer(String name) {
this.name = name;
}
public void start(){
System.out.println(name+"电脑开机了~~");
}
/**
* 提供安装USB设备的入口
*/
public void installUSB(USB usb){
//多态：usb == 可能是鼠标，也可以是键盘
usb.connect();
//独有功能：先判断再强转
if (usb instanceof keyBoard) {
keyBoard k = (keyBoard) usb;
k.keyDown();
}else if(usb instanceof Mouse){
Mouse m = (Mouse) usb;
m.duClick();
}
usb.unconnect();
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}实现main类:
/**
* 目标:USB设备模拟
* 1、定义USB接口：插入和拔出
* 2、定义两个USB的实现类 ：鼠标和键盘
* 3、创建一个电脑对象，创建USB设备对象，安装启动
*/
public class Test {
public static void main(String[] args) {
//1.创建电脑对象
computer c = new computer("外星人");
c.start();
//2.创建鼠标和键盘对象
USB u = new keyBoard("双飞燕");
c.installUSB(u);
USB u1 = new Mouse("逻辑");
c.installUSB(u1);
}
}