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

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

封装

1.控制程序中的访问
通过给类中成员（字段，方法，构造方法）添加访问权限来实现访问控制
2.什么是访问权限：
比如做一个系统，不同人登录进去的访问权限不一样
3.访问权限修饰符：
private < 默认不写(注意不要添加default修饰) < protected < public
private : 最小权限，被它修饰的成员只能够在本类中可以访问到
public ：最大权限，任何地方和任何人都能访问
4.在Java中的体现及步骤

1. 把类中的字段私有化；
2. 给每一个字段都提供一组getter setter方法 (方法的规范写法)；setXxx
   在测试类中尝试创建对象,并通过调用getter setter方法完成 对字段的赋值和取值；
3. 提供一个无参数的构造方法
   5.给对象的字段赋值几种方法
4. 直接访问字段赋值 标准java类 X 字段一般都会给私有化（私有化访问不到）；
5. 通过构造方法赋值 只能够创建对象的时候赋初始值；
6. 通过setXxx方法赋值 更灵活；
   两者不冲突，一般可以在创建的时候赋值，也可以后面进行修改
   6.JavaBean
7. 字段必须私有化
8. 给每一个字段提供合理的getter setter方法
9. 必须有一个公共的无参数的构造方法;

继承

继承概念的引入

1.泛化：在多个子类的基础上面抽取共有属性的行为到一个父类中去
2.特化：在一个父类的基础上拓展子类特有的属性和行为，生成一个新的子类
3.原则：父类存放共性，子类存放特性
4.提高好处：提高了代码的复用性
5.继承到父类 非私有的字段和方法 父类特性

Java类中的继承的语法格式

class Animal{}
class Person extends Animal{} //目标就是为了继承到Animal,这个类型

Java中类的继承特点

1. Java中类的继承只能够是单继承
2. 可以支持多重继承
3. 每一个类都有一个直接父类,如果没有看到显示的继承代码,那么就隐式继承就Object

多态

多态：一种事物的多种形态

官方概念：编译时跟运行时类型不一致就产生了多态
民间概念：父类类型的变量，存放子类类型的对象，可能存放子类类型的对象有多种可能
多态存在的前提：必须有继承关系

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.编译时：
a) aml 编译时，看的是父类类型，会在父类类型中eat方法
b) 如果没有找到，会继续向上找[aml编译时父类类型]
i. 找到：编译通过
ii. 找不到：编译报错
iii. 注意：是不会向下找的[aml编译时子类类型]
2) 运行时 :
a) 先到运行时类型[Person]中找eat方法,
i. 如果找到：就执行,
ii. 没找到：向上到父类中找并执行

编译时与运行时的几种情况分析

1. 父类中有一个方法,子类覆写了
2. 父类中有一个方法,子类没有
3. 父类中没有,子类有一个方法
4. 父类子类都没有
   ----------- 上面都是实例方法,下面来一个静态方法---------------------------------
5. 静态方法
6. 字段没有覆写一说
   分析：
7. 实际开发中一般不会再子类中定义一个和父类同名的字段，
8. 如果是有这样的情况存在，

1. 如果编译时类型父类的类型，取值是父类里面字段的值；
2. 如果编译时类型子类的类型，取值是子类里面字段的值；

多态方法调用以及参数传递应用示例

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);
	}
}

多态体现的几种情况

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语言设计是想，希望将现实生活中的对象与对象之间的关系在计算机系统得以体现