本文详细介绍了面向对象编程的三大特性——封装、继承和多态。重点讲解了this和super关键字的使用，以及如何通过访问权限修饰符控制类的成员变量和方法的访问。同时，讨论了构造方法、方法重写以及继承带来的好处和弊端。通过实例展示了如何在Java中实现这些概念，帮助读者深入理解面向对象编程的核心思想。
面向对象
1. this 和 super 的使用
--------------------------实操--------------------------------------
this.成员变量 : 强制访问本类成员位置上的变量
this.成员方法 : 强制访问本类成员位置上的方法 -> 不会这样写
super.成员变量 : 强制访问本类父类成员位置上的变量
super.成员方法 : 强制访问本类父类成员位置上的方法
super() : 调用父类的无参构造方法
super(实参) : 调用父类的有参构造方法
this() : 调用本类的无参构造方法
this(实参) : 调用本类的有参构造方法
--------------------------理论--------------------------------------
this : 当前对象的引用
解释 : 哪个对象启动含有 this 关键字的方法, this 关键字就是这个启动方法的对象 (动态的)
举例 : 对象.含有this关键字的方法();
作用 : 打破局部位置的访问就近原则的
super : 当前对象的某个父类对象 -> 仅仅是一个关键字,不产生具体的对象
作用 : 打破本类成员位置访问的就近原则 -> 要强制访问本类父类的成员就使用 super.
2. 封装
封装：将类的信息隐藏在类的内部，不让外部直接访问，而是提供公共的方法用于给外界访问
封装的步骤：属性私有 方法公开
属性私有：将属性使用private修饰 表示此属性只能在本类中 其他类不能访问
方法公开：针对每一个属性编写两个方法分别用于实现属性的 赋值/取值
设置值的方法 必须为setXXX() 获取值的方法必须为 getXXX()
面向对象的三大特性 : 封装,继承,多态
封装性 : 包起来
1. 循环体现封装性 : 把重复的代码循环包裹,提高代码的复用性
2. 方法体现封装性 : 把重复的功能方法包裹,提高代码的复用性
3. 描述生活中的事物体现封装性 : 用属性和行为描述一类事物的特征,提高代码的多样性
4. private 体现封装 : 用 private 修饰成员变量,提高代码的安全性
/**
* 企鹅类
* 名字
* 健康值
* 亲密值
* 性别
*
*
* 封装：将类的信息隐藏在类的内部，不让外部直接访问，而是提供公共的方法用于给外界访问
*
* 封装的步骤：属性私有 方法公开
* 属性私有：将属性使用private修饰 表示次属性只能在本类中 其他类不能访问
* 方法公开：针对每一个属性编写两个方法分别用于实现属性的 赋值/取值
*
*/
public class Penguin {
private String name;
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
private int health;
public void setHealth(int health) {
if(health >=0 && health <= 100) {
this.health = health;
}else {
System.out.println("健康值赋值不合理，将使用默认值60");
this.health = 60;
}
}
public int getHealth() {
return health;
}
private int love;
public void setLove(int love) {
if(love >= 0 && love <= 100) {
this.love = love;
}else {
System.out.println("亲密值赋值不合理，将使用默认值60");
this.love = 60;
}
}
public int getLove() {
return love;
}
private String sex;
public void setSex(String sex) {
if(sex.equals("雌") || sex.equals("雄")) {
this.sex = sex;
}else {
System.out.println("性别不合适，使用默认性别雌");
this.sex = "雌";
}
}
public String getSex() {
return sex;
}
}
封装的好处：
- 便于使用者正确使用系统，防止错误修改属性
- 降低了构建大型系统的风险
- 提高程序的可重用性
- 降低程序之间的耦合度
3. 访问权限修饰符
3.1 类的访问权限修饰符
类的访问修饰符：
public：表示本项目中任何位置都可以访问
默认不写：只有在同一个包中才能访问
package com.aqrlmy.test6;
/**
* 类的访问修饰符：
* public：表示本项目中任何位置都可以访问
* 默认不写：只有在同一个包中才能访问
*
*/
public class A {
public static void main(String[] args) {
A a = new A();
B b = new B();
}
}
class B{
public static void main(String[] args) {
A a = new A();
B b = new B();
}
}
package com.aqrlmy.test7;
import com.aqrlmy.test6.A;
//import com.aqrlmy.test6.B;
public class TestAB {
public static void main(String[] args) {
A a = new A();
// B b = new B(); 超出范围 不能访问
}
}
3.2 类成员的访问权限修饰符
类成员(属性、方法、构造方法)的访问修饰符
- private:本类中
- 默认不写：本包中
- protected：本包以及子类
- public:任何位置
/**
* 类成员(属性、方法、构造方法)的访问修饰符
* private:本类中
* 默认不写：本包中
* protected：本包以及子类
* public:任何位置
*/
public class A {
private String field1;
String field2;
protected String field3;
public String field4;
private void m1() {
System.out.println("A类private修饰的方法m1");
}
void m2() {
System.out.println("A类默认修饰的方法m2");
}
protected void m3() {
System.out.println("A类protected修饰的方法m3");
}
public void m4() {
System.out.println("A类public修饰的方法m4");
}
public static void main(String[] args) {
A a = new A();
System.out.println(a.field1);
System.out.println(a.field2);
System.out.println(a.field3);
System.out.println(a.field4);
a.m1();
a.m2();
a.m3();
}
}
如果需要在同一个类中访问两个同名但是不同包的类，可以使用
全限定名访问
4. 继承
子类继承父类，子类与父类是is-a 的关系(子类是父类)
父类中编写共有的信息和行为
子类中编写独有的信息和行为
继承性 : Java中类和类之间的关系
1. Java中类与类之间的继承: 单一继承,多层继承
2. 一个父类可以有多个子类
3. 子类继承父类可以使用父类所有非私有的成员(成员变量和成员方法)
4. 父类对象不会找子类要东西
5. 子类要加载优先加载父类
6. Java中的类都直接或者间接的继承于Object -> Object : 超类,基类,根类
继承的格式
关键字 : extends
格式:
public class Fu{
}
public class Zi extends Fu{
}
public class Son extends Fu{
}
5.继承关系下成员访问的问题
5.1成员变量
继承关系下成员变量(field)的访问特点 : 就近原则, 父类只能访问自己和自己父类的不会找子类要
1. 在子类的方法内访问: 就近原则
this : 作用是打破本类局部位置的约束,强制访问本类成员位置上的变量,方法
this.变量名 : 强制访问本类成员位置上的变量
this.方法名(实参) : 强制访问本类成员位置上的方法 --> 不会用!!方法不可能有局部方法
this 的概念 : 本类对象的引用
哪个对象调用含有this关键字的方法,那么这个this此时就代表这个对象
举例子 : 照镜子
哪个对象调用含有this关键字的方法,就相当于这个对象照镜子,镜子里出现的那个对象就是此时this的指向
super : 作用是打破本类成员位置的访问就近原则,强制访问本类父类的成员 (变量,方法)
super 的概念 : 本类的父类对象(只是一个关键字,不具体指向某个父类对象)
2. 在父类的方法内访问: 父类只会找自己的和自己父类的 不会找子类
3. 在第三方类的方法内访问: "就近原则"
变量访问的原则 : 就近原则
局部位置 < 本类的成员位置 < 本类父类的成员位置
5.2成员方法
继承关系下成员方法的访问特点: 真实对象是什么类型,就调用哪个类中的方法!!
1. 在子类方法中访问 : 自己有就调自己的,自己没有调父类的
2. 在父类方法中访问 : 父类只能访问自己的和父类父类的,不能访问子类的
3. 在第三方类中访问 : 对象是谁就调用哪个类中的方法
6.方法的重写
方法的重载 : Overload
现象级的特性 : 在同一个类中,出现了多个同名方法且不报错,说明在这个类中出现了方法的重载特性
重载的特点:
1. 必须在同一个类中
2. 方法名必须相同
3. 方法的形参列表不同
a. 个数不同
b. 类型不同
c. 类型顺序不同
4. 重载和返回值类型无关
5. 重载和形参的变量名无关
//不构成重载
show(int num1,double num2)
show(int num2,double num1)
方法的重写 : Override -> 方法的覆盖
现象级的特性 : 在继承关系下,子类出现了和父类方法声明一模一样的方法,说明这个方法出现了方法重写的特性
重写的特点:
1. 必须有继承/实现关系 (extends / implements)
2. 子类方法和父类方法声明要完全一致 (百分之99的情况)
方法的修饰符 返回值类型 方法名(形参列表) --> 方法的声明
3. 子类重写方法的方法体可以不一样
何时使用方法的重写呢 ?
子类具备和父类相同的行为,但是完成此行为的方式不一样,那么就可以重写父类的方法(对父类方法进行覆盖),修改此方法的方法体;
方法重写可以不一样的板块 : (除了方法体)
a. 子类方法的权限修饰符 >= 父类方法的权限修饰符
public > protected > 默认不写 > private
b. 子类方法的返回值类型可以不一样
1. 父类方法返回值类型是 void -> 子类必须也是void
2. 父类方法返回值类型是 基本数据类型 -> 子类必须一样
3. 父类方法返回值类型是 引用数据类型
子类方法的返回值类型 <= 父类方法的返回值类型
-> 子类方法的返回值类型可以是父类方法返回值类型的子类或者同类
7.构造方法
注意事项:
1. 每一个构造方法的第一句代码 默认存在 super(); -> 调用父类的无参构造方法
2. 一个构造里只能访问一次其他的构造方法,且不能访问自己
3. 如果你在一个构造方法内访问了其他任意一个构造方法,默认赠送的super就不送了
4. 调用其他构造方法的语句必须在构造方法的第一句代码中
5. 一个类中的构造方法内必须有一个构造方法去加载父类
8.成员变量和局部变量的区别
成员 : 位置关系 -> 类中方法外
局部 : 位置关系 -> 方法内,方法的形式参数列表
1. 位置不同:
成员变量 : 类中方法外
局部变量 : 方法内,方法的形式参数列表
2. 作用域不同: 变量只在其定义的大括号内有效
成员变量 : 在整个类中都有效
局部变量 : 在它所属的方法内有效
3. 在内存中的位置不同 :
成员变量 : 堆内存
局部变量 : 栈内存
4. 生命周期不同 :
成员变量 : 属于对象 -> 随着对象的创建而创建,随着对象的死亡而死亡(回收)
局部变量 : 属于方法 -> 随着方法的进栈而进栈,随着方法的执行完毕(弹栈)而死亡
5. 初始化值不同 :
成员变量 : 有默认值 (在堆中对象内部数据都有默认值)
整数 : 0
浮点数 : 0.0
字符 : '\u0000'
布尔 : false
所有的引用数据类型 : null
局部变量 : 没有默认值 (局部变量未赋值不能直接使用)
记忆方法:
因为在类中的位置不同,导致作用域不同和在内存中的位置不同;
因为在内存中的位置不同,导致生命周期不同和初始化值不同;
9.继承的好处和弊端
好处 :
1. 提高代码的复用性 -> 抽取子类们的共性,在父类中写一次,子类们都可以不写了!
2. 约束子类的行为 -> 父类看子类的角度
3. 功能的拓展 -> 子类看父类的角度
弊端 : (最终境界 : 高内聚,低耦合)
内聚 : 自己完成功能的能力
耦合 : 依赖关系
继承提高了代码的耦合性
该继承的时候果断继承! 继承是利大于弊!!
10.不能继承哪些内容
构造方法只能被调用，不能被继承。
405
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
