面向对象的特征（封装，继承，多态）

1.理解什么是封装（日常认知）

现实生活中封装概念的引入

1.大家想一想生活中封装是什么？包装 ：快递 ：打包
a.例如： 浩浩去网上买了个充气娃娃{ 需要打包 }安全，隐式 ，保密 扎两针
b.例如： 买了一条狗狗活的：{打包} 准备吃狗肉…打包就需要透气，外界交流
c.必须是你打开：只要有一定权限的人就可以打开
d.台式机电脑：机箱[ 主板 显卡 内存 电源 硬盘。。。]

2.如上示例的共同点总结：
通过封装的操作，可以达到从物理层面控制访问（外面不能轻易访问到里面内容–》这个就是物理层面）
3.那Java程序是如何进行封装呢？ 怎么封装上面的机箱呀？
5.2 Java中的封装如何体现
1.程序中一切都是虚幻的：电脑类：伪代码：
class 电脑{
private 主板
public 内存
硬盘
电源
}
2.如何控制程序中的访问 ？
通过给类中的成员（字段，方法，构造方法）添加访问权限来实现访问控制
3.什么是访问权限：
例子：比如做一个系统，不同人登录进去，的访问权限不一样；
4.访问权限修饰符： private < 默认不写（注意不要添加default修饰）< protected < public
private ：私有的 最小权限，被它修饰的成员只能够在本类中可以访问到；
public ：公共的 最大权限，任何地方和任何人都能访问；
5.测试：变量 age是private修饰的（私有的）只能够在Student本类中可以被访问
class Test{
public static void main(String[] args) {
int age = new Student().age;
}
}
class Student{
private int age = 10;//私有化的只能本类中可以访问
}
---------- Javac ----------
Test.java:3: 错误: age可以在Student中访问private
int age = new Student().age; ^
1 个错误
输出完成 (耗时 0 秒) - 正常终止

6.为什么需要将字段私有化起来： 安全
5.3封装的步骤
1.上面的代码把name age 私有化 [提供private 修饰 ]之后就不能够操作了，
2.怎么去赋值和取值呢？提供setget方法
3.提供一个无参数的构造方法:标准的javaBean
/*
设计方法存值取值
public 需要，给别人访问的
static 不需要：修饰方法，字段也需要静态修饰，静态修饰的字段被该类的所有对象共享
返回值：存值void 不需要返回值，取值对应字段类型
方法名字：存值setName 取值getName : 特殊情况 布尔类型的字段get 变 is
参数：存值对应字段类型，取值不需要参数
*/
class Student{
private String name;
private int age;
private boolean sex;
public void setName(String n){
name = n;
}
public String getName(){
return name;
}
public void setAge(int a){
age = a;
}
public int getAge(){
return age;
}
public void setSex(boolean s){
sex = s;
}
public boolean isSex(){
return sex;
}
}

2.继承

2.1 继承概念的引入
1.专业解释：
1)泛华：在多个子类的基础上面抽取共有属性的行为到一个父类中去
2)特化：在一个父类的基础上拓展子类特有的属性和行为，生成一个新的子类
3)原则：父类存放共性，子类存放特性
2.代码理解：
1)三个类都有重复的代码，可以把这部分内容 抽出去，抽出去放到另外一个类里面；
a.上面的类我们叫做 父类（超类，基类，根类）
2)下面的3个类和上面的类需要发生一点关系【继承】
a. 下面的类我们叫做 子类（派生类，拓展类）
3.提取好处 : 提高了代码的复用性
3.2.2 Java中类继承的基本语法
1.Java类中的继承的语法格式:
class Animal{}
class Person extends Animal{} //目标就是为了继承到Animal,这个类型

A 就是B的父类; B是A的子类

1)没有导包Arrays:
2)class Tools extends java.util.Arrays{ }
3)导包了Arrays
4)class Tools extends Arrays{ }

2.验证:子类中是否可以继承到父类中的东西(通过创建子类对象来操作从父类继承的东西)
class Animal{
String name;
void eat(){
System.out.println(“吃实物”);
}
}
class Person extends Animal{
}
class Pig extends Animal{
}
测试类：
public class Test {
public static void main(String[] args) {
Person person = new Person();
person.name = “人胖”;
System.out.println(person.name);
Pig pig = new Pig();
pig.eat();
}
}
2.3 子类可以从父类继承哪些成员？
1.思考 : 一个父类中可能有哪些? 字段 方法 构造方法
2.思考 : 可能还和访问权限有关 private public
3.验证 :非私有的字段 和方法 可以被继承到（暂时这样记忆-主要是从是否可以访问的层面考虑）
4.构造方法不能够被继承:java规定
5.子类可以继承到父类的特性class MyFrame extends java.awt.Frame{}
class Person extends Animal{
Animal(){};
}
---------- Javac ----------
Test.java:20: 错误: 方法声明无效; 需要返回类型
Animal(){};
^
1 个错误
输出完成 (耗时 2 秒) - 正常终止
2.4 Java中类的继承特点
1.Java中类的继承只能够是单继承
2.可以支持多重继承
3.每一个类都有一个直接父类,如果没有看到显示的继承代码,那么就隐式继承就Object

3.多态

3.1 多态的引入
1.简单理解一种事物的多种形态
2.示例：
a)今天晚上请大家吃大餐 : 思想上的大餐 , 凉开水
b)同学们准备买一辆车: 宾利 兰博基尼 柯塞尼格
c)同学们要上天 : 坐飞机,
3.java代码中的体现

1)一个动物就是一个蛇
2)一个动物就是一个猪
3)一个动物就是一个人
4)一个人就是一个动物：Animal aml = new Person();//一个动物变量中，可能存放子类对象的多可能
5)一个猪就是一个动物：Animal aml = new Pig();
6)一个蛇就是一个动物：Animal aml = new Snak();
7)一个人就是一个猪
8)一个蛇就是一个人
9)一个猪就是一个蛇

3.2 什么是多态
1.一个人就是一个动物：
(1)Animal aml = new Person();//一个动物变量中，可能存放子类对象的多种可能
2.理解：使用aml：编译是看的是Animal类型，运行时看的是实际存放的对象[真实类型]
3.官方概念：编译时跟运行时类型不一致就产生了多态
4.民间理解：父类类型的变量，存放子类类型的对象，可能存放子类类型的对象有多种可能
5.多态存在的前提：必须有继承关系
3.3 多态方法调用编译运行过程[重点]
class Animal{
void eat(){
System.out.println(“食物…”);
}
}
class Person extends Animal{

}
//----------------------------------测试类-----------------------
class Test {
public static void main(String[] args) {
Animal aml = new Person();
aml.eat();
}
}

1.上面两句代码的编译,运行过程:
1)编译时 :
a)aml 编译时，看的是父类类型，会在父类类型中eat方法
b)如果没有找到，会继续向上找[aml编译时父类类型]
i.找到：编译通过
ii.找不到：编译报错
iii.注意：是不会向下找的[aml编译时子类类型]
2)运行时 :
a)先到运行时类型[Person]中找eat方法,
i.如果找到：就执行,
ii.没找到：向上到父类中找并执行
2.思考 : 有没有可能编译通过了,而运行找不到方法… 不可能!
3.4 编译时与运行时的几种情况分析
1.父类中有一个方法,子类覆写了
2.父类中有一个方法,子类没有
3.父类中没有,子类有一个方法
4.父类子类都没有
----------- 上面都是实例方法,下面来一个静态方法---------------------------------
5.静态方法
6.字段没有覆写一说
分析：
1.实际开发中一般不会再子类中定义一个和父类同名的字段，
2.如果是有这样的情况存在，
1)如果编译时类型父类的类型，取值是父类里面字段的值；
2)如果编译时类型子类的类型，取值是子类里面字段的值；

3.5 多态方法调用以及参数传递应用示例[重点]
class Dog{//父类类型Dog
void eat(){
System.out.println(“吃食物”);
}
}
class DDog extends Dog{//子类类型DDog
void eat(){
System.out.println(“哈根达斯”);
}
}
class XDog extends Dog{//子类类型XDog
void eat(){
System.out.println(“吃牛排喝红酒”);
}
}
class Person{//人类：定义喂狗方法
void feedDog(Dog dog){
dog.eat();
}
}
//------------------------------测试类-----------------------------------
class Test {
public static void main(String[] args) {
Dog ddog = new DDog();
XDog xdog = new XDog();

	Person pson = new Person();
	pson.feedDog(ddog);
	pson.feedDog(xdog);
}

}

3.6 多态体现的几种情况
1.如上代码多态的体现的本质：都是父类类型的变量存放子类类型的对象
2.Dog dog = new XDog();//核心本质
3.方法参数传递：方法形参父类类型，允许传子类类型对象
i.Dog dog = new XDog();
ii.XDog xdog = new XDog();
iii.void feedDog(Dog dog){ }//此方法运行传递上面两个参数dog 或者 xdog : 本质传递的都是子类对象
4.方法返回值
Dog getDog(){//此方法返回值类型为父类类型Dog
return new XDog();//允许返回子类类型
}
思考：方法内部返回值的类型一定是，方法返回值位置指定的类型么？
5.多态的好处：屏蔽了不同子类之间实现的差异
6.加强面向对象编程思想：
a)此处体现java语言设计是想，希望将现实生活中的对象与对象之间的关系在计算机系统得以体现