11.封装和继承

封装和继承

一.掌握什么事封装

**一个好的系统：**高内聚，低(松)耦合(功能之间相互独立，没有影响，不会牵一发而动全身)。世界上没有完美的系统，只有接近完美的系统。

封装的作用（为什么需要封装）：
1.如果没有封装，name一个类中属性，可能会出现不合理赋值；
2.便于使用者正确使用系统，防止错误修改属性；
3.有助于系统之间的松耦合，提高系统独立性；
4.提高软件的可重用性；
5.降低了构建大型系统的风险。

封装的定义：
将类的信息隐藏在类的内部，不允许外部程序直接访问，而是通过类提供的公开的便捷的接口来（对隐藏的信息）访问赋值等。

原则：
尽可能多的隐藏信息，都通过公开的接口来访问。

二.掌握如何使用封装

一个类的封装过程：
1.属性私有化
2.提供公共的getter/setter方法
3.在getter/setter方法中添加控制语句(根据需求)

public class Monkey {
​
// 1.属性私有化-隐藏类信息 除了自己这个类 其他的外部类都无法直接访问
private String name;
private int health;
private int love;

// 2.提供公共的getter/setter方法-用于外部访问操作(便捷的接口)
// name的setter方法
public void setName(String name) {
    this.name = name;
}
// name的getter方法
public String getName() {
    return this.name;
}

public int getHealth() {
    return health;
}

// 3.根据你的【实际需求】  去在对应的getter/setter方法中添加控制语句
public void setHealth(int health) {
    if(health < 0 || health > 100) {
        System.out.println("健康值非法！已经设置为默认值60！");
        this.health = 60;
    }else {
        this.health = health;
    }
}

public int getLove() {
    return love;
}
public void setLove(int love) {
    this.love = love;
}

}

三.包的作用和使用

为什么需要包：
1.因为在各个平台系统中，同一个目录下不允许出现同名文件；
2.当我们文件（Java代码等）越来越多的时候，全都放在一起会显得杂乱，不易管理，有一定规则的包可以解决此问题。
3.有助于实施访问权限控制。

使用包：
1.包的命名规则：
①.所有字母小写（大多数情况下）；
②.采用反域名命名法（公司域名的倒序） 例如：cn.kgc.xxx；
③.各级包应该有一定的规范：（根据不同公司会有出入）
一般都是四级包，可能有更多级，根据具体需求
cn：一级包
kgc：二级包 公司的名称
项目的名称：三级包
模块或者层级名：四级包
例如：com.neteasy.cloudmusic.ui…

2.声明包地址
// 声明包地址的 它必须在文件的有效代码的第一行
package cn.kgc.demo2;

3.导入包（Eclipse快速导包：Ctrl+Shift+O）
// 导包：如果你要使用的类[不再同一个包下] 你就需要将它的地址导入过来
// 导包的语句必须是在类声明的上方，包声明的下方
// 语法：import 类的全类名/全路径/全限定名;(它也支持通配符)
// import java.util.*;
import java.util.Scanner;

java.lang包下的类，不需要你手动声明，JVM会自动进行加载。
例如：System

4.特殊情况：
// 如果在一个类中，出现了使用两个不同包的同名类 必然有一个需要以全类名形式使用
cn.kgc.demo1.Cat cat = new cn.kgc.demo1.Cat();

四.访问修饰符

**private：**最严格的访问级别，只能在本类中使用；
**什么都不写（默认）：**同包之间可以随意访问；
**protected：**在不同包中，只要有子父类继承关系，那么子类中就可以访问；
**public：**在整个项目里都能使用。

访问修饰符：
可以修饰类，修饰属性，修饰方法。
作用：
为了隐藏某些细节，或者公开某些内容，控制访问权限。

五.static关键字

作用：
1.static可以修饰成员变量：静态变量/类变量
静态变量它是随着类的加载而加载，它被这个类所有对象共享。
**普通成员变量（实例变量）**它是随着对象的创建而产生，贼不同的对象之间，是互相独立的。
**2.static也可以修饰方法：**静态方法/类方法
A:B都是方法 S修饰的都是静态方法。

静态方法的调用：
同一个类中方法之间调用：​
**A（S）—>B：**不能直接调用，因为B不是静态方法它是随着对象的调用才产生的。​
**B—>A（S）：**可以创建对象去调用，也可以直接就使用。​
**A（S)—>B(S)：**可以直接调用。不同类中的方法之间调用：​
**B—>A（S）：**可以创建对象去调用，也可以直接就使用。类名.方法名（）​
**B(S）—>A（S)：**可以创建对象去调用，也可以直接就使用。类名.方法名（）它的使用除了创建完对象调用，还可以直接类名.方法名（）

普通方法的调用：
同一个类中方法之间调用：​
直接调用。 方法名（）；
不同类中的方法之间调用：​
它的使用必须先创建对象。
它的使用必须创建完对象调用

**3.static 也可以修饰代码块：**静态代码块

public class Dog {
// 成员代码块/构造代码块/非静态代码块：会随着对象的创建而执行里面的代码片段(创建一次对象就执行一次) 它优先于构造方法执行
{
}
// 静态代码块：会随着类的加载而执行里面的代码片段(只会执行一次)
static {

}
}

static修饰的类信息和普通的成员变量（实例/对象）信息等的区别：
1.生命周期不同
类信息随着类加载而创建
实例信息随着对象产生而创建
2.“作用域”不同
类信息被改来的所有对象共享，只要有一个对象更改，所有的对象的结果都会变化
实例信息仅仅被自身对象使用，不同对象之间的实例信息相互独立存在
3.调用上有所不同
类信息或类方法等，直接可以用类名的形式调用（当然也可以用对象来调用）
实例信息或实例的方法等必须通过先创建对象，然后才能使用

4.注意事项：
**1.**如果在多个对象之间，有共享的数据，且这个数据不会发生变动，最好定义为静态常量，可以有效提升效率。
static final修饰…
**2.**在类信息中，如果使用实例信息，需要注意先创建对象才能使用。反之则无所谓。（自己死开谁先出生和谁后出生）

六.继承的作用和使用

继承的作用：
便于复用代码
将子类中共有的代码，提取出来存储到父类中，到时候用子类继承父类就可以重复使用父类中的代码

继承的使用：
定义父类：
public class Pet{
// 子类公有的代码
}
定义子类：
public class Dog extends Pet{
// 子类特有的代码
}

面向对象的三大特性之一就是继承。
Java：单根继承，一个子类只能有一个直接父类。(一个人只可能有一个亲爹)
在设计使用继承优化时，尽量符合is a的关系。
例如：猫 is a 宠物 学生 is a 人

理解继承
父类不是所有的内容都能被子类继承
1.父类私有的（private修饰的）
2.父类的构造方法不能被继承
3.如果父类和子类不是在同一个包中，那么父类中的 默认修饰符修饰的内容 不能被继承

执行流程的特点（谁先执行）
**1.**子类的构造方法中，如果没有显示的去调用父类的构造或者调用自己的其他构造
那么：系统会默认调用父类的无参构造

super关键字
**this：**当前对象，谁在调用这个方法谁就是对象
this（）；//调用自己的构造
this.方法（）；//调用自己的方法
this.成员变量();//调用自己的属性
**super：**父类的对象 谁是它的父类，这个对象就属于谁
super（）；//调用父类的构造
super.方法（）；//调用父类的方法
super.成员变量();//调用父类的属性

**2.**如果子类在构造中，显示的去调用了父类的某个构造
那么：系统就会执行对应的构造，而不再执行默认的无参构造。

**3.**如果子类在构造中，显示的去调用了自己的某个构造
那么：系统就会先去执行你自己的那个构造，而那个构造中也会根据上两条情况区别执行对应的父类构造