封装
一、封装的好处
1、提高安全性
2、提高复用性
3、将复杂的事情简单化
二、Java中的封装体
1、方法安全性：调用者不知道方法的具体实现
2、复用性：方法可以被重复使用
3、简单化：将繁多的代码以一个方法的方式呈现，仅通过调用方法就可以实现功能；代码维护也变得简单类
三、private修饰成员变量
四、构造方法
构建、创造，也叫构造器，用来帮助创建对象的方法，准确的说，构造方法的作用是初始化对象
格式：
修饰符构造方法名(参数列表){//方法体}
public class Student {
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String name;
private int age;
public void study() {
System.out.println(this.name);
System.out.println("-------------------");
System.out.println(this.age);
}
}
要求：
1、方法名必须与类名相同
2、没有返回值
3、没有返回值类型
注意事项
1、若未提供任何构造方法，系统会给出默认无参构造
2、若已提供任何构造方法，系统不再提供无参构造
3、构造方法可以重载
Java中封装的概念
将一系列相关事物共同的属性和行为提取出来，放到一个类中，隐藏对象的属性和实现细节，仅对外提供公共的访问方式。
隐藏对象数据的实现细节，意味着一个类可以全面的改变存储数据的方式，只要使用同样的方法操作数据，其它对象就不会知道或介意所发生的变化。
封装的关键
==绝对不能让类中的方法直接访问其它类的数据（属性），程序仅通过对象的方法与对象的数据进行交互
继承
一、Java中的继承
通过扩展一个类来建立另外一个类的过程，叫做继承（inheritance）
通俗地说，所谓继承，就是让类与类之间产生父子关系。
所有的类都直接或间接的继承自：
java.lang.Object被继承的类叫做父类（基类、超类）继承的类叫做子类（派生类）
二、格式（extends）
class父类{
//...
}
class子类extends父类{
//...
}
// 调用类
public class Test {
public static void main(String[] args) {
Dog d = new Dog("小白");
d.setName("小黑");
d.output();
}
}
//父类 动物类
public class Animal {
public String name;
public int age;
public Animal(int age) {
this.age = age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
}
//子类 Dog类
public class Dog extends Animal {
public String name;
public Dog(String name) {
super(10);//调用父类构造 如果不写系统会默认调用
this.name = name;
}
public String getName() {
return name;
}
public void output() {
//super.父类方法 子类调用父类方法
System.out.println("父类的名字是" + super.getName());
//this.父类方法 子类调用子类方法
System.out.println("子类的名字是" + this.getName());
}
}
三、子类继承父类之后有什么效果？
子类拥有了父类的非私有成员（成员变量、成员方法）
父类的私有成员不能被继承
四、继承的优缺点
优点：
1、功能复用
2、便于扩展新功能
3、结构清晰，简化认识
4、易维护性
缺点：
1、打破了封装性
2、高耦合性
五、this和super的区别
1. 查找变量的原则：就近原则
2. 查找变量的顺序：局部变量成员变量父类更高的父类...Object
3. 访问父类变量的方式： super.父类变量名;
4. super：当前对象父类的引用（父类内存空间的标识）
5. 对象初始化顺序：先初始化父类内容，再初始化子类内容
6、this：当前实例化对象
多态
//父类 动物类
public class Animal {
public String name;
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void eat() {
System.out.println("吃饭");
}
}
//子类 Dog类
public class Dog extends Animal {
@Override //重写父类的eat方法
public void eat() {
System.out.println(getName()+"吃骨头");
}
}
//子类 Pig类
public class Pig extends Animal {
@Override
public void eat() {
System.out.println(getName()+"吃面条");
}
}
// 调用类
public class Test {
public static void main(String[] args) {
Dog d = new Dog();
d.setName("小白");
showAnimal(d);
Pig p = new Pig();
p.setName("小花");
showAnimal(p);
}
//传统调用
public static void showAnimal(Dog d) {
d.eat();
}
public static void showAnimal(Pig p) {
p.eat();
}
//多态调用
//多态的使用场景：父类型可以作为形参的数据类型这样可以接受其任意的子类对象
public static void showAnimal(Animal an) {
an.eat();
}
}
一、什么是多态？
多种状态，同一对象在不同情况下表现出不同的状态或行为
二、Java中实现多态的步骤
1、要有继承（或实现）关系
2、要有方法重写
3、父类引用指向子类对象（is a关系）
为什么父类引用可以指向子类对象？
因为二者满足子类、父类的关系，所以任何一个Dog都可以Animal的形式使用
加载类：
创建子类对象时，先加载父类，再加载子类
构造方法：
先执行父类的构造方法，初始化子类对象的父类成员部分然后再初始化子类成员部分
成员方法：
类的成员方法在方法区开辟空间并有一个地址值，该类的每一个对象都会记录方法区中的地址
在类的加载过程中，创建虚拟方法表，记录了子父类方法重写关系的信息。通过父类引用调用方法时，会查找虚拟方发表，看该方法是否被重写，如果表中记录了重写信息，则执行子类的重写方法。
多态的好处和弊端
多态的好处可维护性：
基于继承关系，只需要维护父类代码，提高了代码的复用性，大大降低了维护程序的工作量
为什么要学习多态：
从程序的模块化和复用性来解释
封装：隐藏数据的实现细节，让数据的操作模块化，提高代码复用性
继承：复用方法，从对象的行为这个层面，提高代码的复用性
多态：复用对象，程序运行时同一个对象表现出不同的行为
可扩展性：把不同的子类对象都当作父类看待，屏蔽了不同子类对象间的差异，做出通用的代码，以适应不同的需求，实现了向后兼容
多态的弊端
不能使用子类特有成员
解决办法：
向下转型（前提：必须准确知道该父类引用指向的子类类型）
类型转换
当需要使用子类特有功能时，需要进行类型转换
```
向上转型（自动类型转换）//子类型转换成父类型Animal animal = new Dog();
向下转型（强制类型转换）//父类型转换成子类型Dog dog = (Dog)animal;
注意事项
只能在继承层次内进行转换，否则可能造成异常（ClassCastException）将父类对象转换成子类之前，使用instanceof进行检查
```