课程笔记Day09
- 封装
- 权限修饰符
- 继承
- final 关键字
第一章 封装
第01节 基础理论
面向对象三大特性
1. 封装性
2. 继承性
3. 多态性
什么是封装呢?
类的封装
封装就是对 一些属性和行为的包装。将属性和行为包装成为类。通过创建对象的方式,去使用属性和行为。
生活实例:
有一个名字叫旺财的事物,他有3岁,可以看家,可以吃肉,还可以卖萌,还可以溜。
那么我们将这种 属性和行为封装成为狗。
使用狗的对象,就可以完成上面的操作(旺财、3岁、看家、卖萌....)
方法封装
我们将一些常用的写法,常用的逻辑,封装成为一个方法,直接调用方法就可以了。
例如:如果我们对于数组的循环遍历,操作比较多。这种情况下,我们就可以将数组的循环遍历,封装成为方法。
系统提供了一个方法 Arrays.toString(数组名称); 这里 toString()方法当中的细节,不让你看到,直接丢参数,得到结果就可以。
属性封装
有时候,我们需要将属性(成员变量)隐藏起来,不让外界访问,这种情况下可以使用 private 关键字。
这里如果采用 private 去修饰成员变量,外界是不能直接访问的。这也是属性封装的一种体现。
第02节 private封装
案例代码
学生类
//学生类
public class Student {
String name;
private int age;
//构造方法
public Student(String name, int age) {
this.name = name;
if(age>=0 && age < 400) {
this.age = age;
}
}
public void show(){
System.out.println("name = " + name);
System.out.println("age = " + age);
}
}
学生类
//测试类
public class Test {
public static void main(String[] args) {
//创建对象
//Student stu = new Student();
//stu.name = "赵兴哲";
//stu.age = -20;
Student stu = new Student("赵兴哲",-20);
stu.show();
}
}
效果图
第03节 JavaBean
理论说明
JavaBean 是类的一种标准写法:包含有
1. 成员变量 private修饰
2. 成员方法 getXxx 和 setXxx
3. 构造方法 无参数构造方法 和 全参数构造方法
快捷键:
在代码区域,右键选择 Gener... 生成构造方法 Con... 生成 getter And setter
案例代码
手机类
//手机类
public class Phone {
//成员变量
private String brand;
private int price;
public Phone() {
}
public Phone(String brand, int price) {
this.brand = brand;
this.price = price;
}
public String getBrand() {
return brand;
}
public void setBrand(String brand) {
this.brand = brand;
}
public int getPrice() {
return price;
}
public void setPrice(int price) {
this.price = price;
}
}
测试类
//测试类
public class Test {
public static void main(String[] args) {
//使用方式一:无参数构造+setXxx 赋值 getXxx取值
Phone one = new Phone();
one.setBrand("华为P40");
one.setPrice(8000);
String brand1 = one.getBrand();
int price1 = one.getPrice();
System.out.println("brand1 = " + brand1);
System.out.println("price1 = " + price1);
//使用方式二:全参数构造 赋值 getXxx取值
Phone two = new Phone("小米8S",4000);
String brand2 = two.getBrand();
int price2 = two.getPrice();
System.out.println("brand2 = " + brand2);
System.out.println("price2 = " + price2);
}
}
第二章 权限修饰符
第01节 基础理论
权限修饰符是什么意思呢?
权限修饰符就是 指明: 类、方法、变量。他们的作用范围。 在什么地方可以使用到他们。
例如: 变量
1. 在不同的包当中,想要去使用变量,应该使用什么权限修饰符?
2. 在同一个包,不同类当中,想要去使用变量,应该使用什么权限修饰符?
3. 在不同的包,但是属于父子类关系,可以使用什么权限修饰符?
4. 只能在同一个类当中,应该使用什么权限修饰符?
小结:
权限修饰符干嘛用的?
解决在不同位置,访问权限的问题。
常用的权限修饰符有哪些呢?(从大到小)
1. public 公共的 【使用较多】
2. protected 受保护的
3. 不写 默认的
4. private 私有的 【使用较多】
第02节 不同修饰符
public 公共的 | protected 受保护的 | 不写 默认的 | private 私有的 | |
---|---|---|---|---|
不同包,不同类(陌生人) | YES | NO | NO | NO |
不同包,子类(我儿子) | YES | YES | NO | NO |
同一个包,非子类(我邻居) | YES | YES | YES | NO |
同一个包,同一个类(我自己) | YES | YES | YES | YES |
小结: 重点是 public 和 private
1、什么时候采用 public ?
类使用 public
构造方法 使用 public
成员方法 使用 public
2、什么时候采用 private ?
成员变量 使用 private
单例模式和工具类的 构造方法 使用 private
第三章 继承
第01节 继承的格式
格式
class 父类名称{
}
class 子类名称 extends 父类名称{
}
案例
小结
继承有什么作用呢?
向上抽取共性,提高代码的复用性。(大白话:偷懒的一种思想)
第02节 成员变量特点
案例代码
父类
//父类
public class FuLei {
String name = "王健林";
int ageFu = 60;
}
子类
//子类
public class ZiLei extends FuLei{
String name = "王思聪";
int ageZi = 30;
public void show(){
String name = "熊猫TV";
System.out.println(name); //熊猫TV
System.out.println(this.name); //王思聪
System.out.println(super.name); //王健林
}
}
测试类
//目标:继承当中,成员变量的特点
public class Test {
public static void main(String[] args) {
//创建子类的对象,调用成员变量
ZiLei zi = new ZiLei();
System.out.println(zi.ageFu); // 60
System.out.println(zi.ageZi); // 30
System.out.println(zi.name); //王思聪
//规则: 成员变量,看等号左边,左边是谁,优先使用谁,没有则向上找
System.out.println("---------");
zi.show();
}
}
//如果在子类方法当中,想要去访问变量。遵循的是"就近原则"
//就近原则:谁离我近,我就优先使用谁。
//如果想要打破就近原则,则需要使用关键字 this 和 super
//如果采用的是 this.变量名称 则表示 本类成员变量
//如果采用的是 super.变量名称 则表示 父类成员变量
效果图
第03节 成员方法特点
案例代码
父类
//父类
public class FuLei {
public void methodFu(){
System.out.println("父类不同方法");
}
public void show(){
System.out.println("父类相同方法");
}
}
子类
//子类
public class ZiLei extends FuLei{
public void methodZi(){
System.out.println("子类不同方法");
}
public void show(){
System.out.println("子类相同方法");
}
public void function(){
this.show(); //子类相同方法
super.show(); //父类相同方法
}
}
测试类
public class Test {
public static void main(String[] args) {
//创建子类的对象,调用方法
ZiLei zi = new ZiLei();
zi.methodFu(); //父类不同方法
zi.methodZi(); //子类不同方法
zi.show(); //子类相同方法
//规则:成员方法看等号右边,等号右边是谁,则优先使用谁,没有就向上找
System.out.println("-----");
zi.function();
}
}
第04节 方法重写
基础理论
1. 什么是方法重写呢?
在父子关系当中,出现了子类方法和父类方法,声明相同的情况。(方法名称相同,参数列表相同,返回值相同)
2. 两个易混淆的概念:
A. 方法重载: 同一个类,同名方法,参数不同。(参数的类型不同,参数的顺序不同,参数的个数不同)
B. 方法重写: 父子关系,相同方法。(出现在两个类当中的方法)
3. 方法重写有什么作用呢?
当父类方法无法完全满足,现有子类需求的情况下,我们就可以在子类当中,对父类方法进行重写,满足现有的儿子需求。
效果图
案例代码
手机类 父类
//手机类
public class Phone {
public void call(){
System.out.println("显示号码");
}
}
新手机类 子类
//新款手机
public class NewPhoe extends Phone{
//注解 Override 表示检查是否是正确的方法重写
@Override
public void call(){
super.call();
System.out.println("显示头像");
System.out.println("显示名称");
}
}
测试类
//测试类
public class Test {
public static void main(String[] args) {
//创建子类的对象
NewPhoe np = new NewPhoe();
//调用方法
np.call();
}
}
//显示号码
//显示头像
//显示名称
//方法重写的应用场景:
//当父类方法无法满足现有子类需求的时候,在子类当中,选择方法重写
//经典的场景就是 升级工作
注意事项
一大一小:
一大:子类的权限修饰符 >= 父类权限修饰符 【父类私有方法,不能被重写】
一小:子类的返回值类型 <= 父类的返回值类型 class Integer extends Number extends Object{ ... }
第05节 构造方法特点
基础理论
1. 继承当中,构造方法的访问特点是什么?
在创建子类对象的时候,优先执行父类构造,再去执行子类构造。
2. 原因是什么呢?
因为在子类当中,可能会使用到父类的成员变量,必须先帮父类初始化成员变量。
3. 注意事项:
在任何一个构造方法的第一行都是 super(); 不写的时候,系统会默认赠送一个给你。
如果写了 super(参数) 或者是 this(参数) 系统将不再赠送 super();
目的是为了让你访问父类的构造方法。
案例代码
父类
//父类
public class FuLei {
private String name;
private int age;
public FuLei() {
}
public FuLei(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
子类
//子类
public class ZiLei extends FuLei {
private String gender;
public ZiLei() {
}
public ZiLei(String name, int age, String gender) {
super(name, age);
this.gender = gender;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
}
测试类
//测试类
public class Test {
public static void main(String[] args) {
//创建子类对象
ZiLei zi = new ZiLei("定浩",18,"女");
//获取值
String name = zi.getName();
int age = zi.getAge();
String gender = zi.getGender();
System.out.println("name = " + name);
System.out.println("age = " + age);
System.out.println("gender = " + gender);
}
}
第06节 继承的特点
继承特点
单一继承,多层继承。
单一继承: 一个类只能有一个直接父类。(只能有一个亲爹)
多层继承: 一个类除了有一个亲爹外,还可以有亲爷爷。(有爹有爷)
画图说明
第07节 两个关键字
基础理论
1. this
A. 含义:
当前对象的引用
B. 用法:
a. 成员变量 this.变量名称
b. 成员方法 this.方法名称(参数);
c. 构造方法 this(参数);
2. super
A. 含义:
当前对象的父类引用
B. 用法:
a. 成员变量 super.变量名称
b. 成员方法 super.方法名称(参数);
c. 构造方法 super(参数);
画图说明
第四章 final关键字
第01节 基础理论
final 关键字的含义:
final 翻译成为中文: 最终的、最后的。不可以改变的。
final 有什么作用呢?
A. 修饰类: 表示的是最终的类。没有子类,下面所有的方法,都不可以被重写。
B. 修饰方法:表示的是最终的方法。这个方法不可以被重写。
C. 修饰变量:表示的是当前的变量,值不可以改变。是常量。
第02节 案例代码
final 修饰类的情况
例如:我们java当中的字符串类 String 就是被 final 修饰。字符串没有子类,所有的方法都不可以被重写。
final修饰方法的情况
如果后期:想要实现当前类里面 某个方法不要被重写,其他的方法,还是可以被重写的情况。
这里就可以将 该方法,设置 final 修饰,其他方法还是可以被重写的。
final 修饰变量的情况
修饰的是 基本数据类型,如果是基本数据类型,表示的是 值不能变。
修饰的是 引用数据类型,如果是引用数据类型,表示的是 地址值 不能变。
今日总结:
Java语言有三大特性:封装、继承、多态。
- 封装:主要是将类中的部分代码实现细节隐藏、封装起来,不直接对外提供访问;
- 继承:主要体现的父子类的关系上,提高了软件的可重用性和可扩展性;
- 多态:包括编译时多态和运行时多态,通过调用不同参数或名称的方法来决定父类对象动态调用哪个子类方法,增强了代码的灵活度。
为什么不能用private封装外部类?
Java封装特性的本质作用是减少代码耦合度,隐藏内部实现细节,控制内部代码的可见性。private修饰成员变量,可以考虑使用get/set方法对外提供访问入口;private修饰成员方法,可以让内部其他方法访问;private修饰内部类,可以让外部类访问。但是,如果private修饰了外部类,那就没法进行访问了,那这个封装的外部类就没有存在的意义了,因此Java不允许适用private修饰外部类,只允许使用public、default这两种级别的权限修饰符进行控制。
3、简述Java继承后的各个成员的特点。
1、成员变量
如果子类父类中出现不重名的成员变量,这时的访问是没有影响的;
如果子类父类中出现重名的成员变量,这时的访问是有影响的。
2、成员方法
如果子类父类中出现不重名的成员方法,这时的调用是没有影响的;
如果子类父类中出现重名的成员方法,可分为方法重载和方法重写两种情况。其中,如果子类中出现与父类一模一样的方法时(返回值类型,方法名和参数列表都相同),会出现覆盖效果,也称为重写或者复写。
3、构造方法
构造方法的名字是与类名一致的。所以子类是无法继承父类构造方法的。
子类的初始化过程中,必须先执行父类的初始化动作。子类的构造方法中默认有一个 super() ,表示调用父类的构造方法,父类成员变量初始化后,才可以给子类使用。
4.简述Java中的final关键字及用法。
- final修饰类:表示最终类,也就是此类不能被继承;
- final修饰变量:表示常量,也就是一个变量的值始终如一,无法变更;
- final修饰方法:表示最终方法,也就是此方法不能被重写。