封装 继承 多态_面向对象（二）封装，继承，多态

封装

• 理解什么是封装

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

1. 包装 ：快递 ：打包

a. 安全，隐式 ，保密

b. 外界交流

c. 必须是你打开：只要有一定权限的人就可以打开

2. 如上示例的共同点总结：

通过封装的操作，可以达到从物理层面控制访问（外面不能轻易访问到里面内容--》这个就是物理层面）

• Java中的封装如何体现

1. 如何控制程序中的访问 ？

通过给类中的成员（字段，方法，构造方法）添加访问权限来实现访问控制

2. 什么是访问权限：

例子：比如做一个系统，不同人登录进去，的访问权限不一样；

3.访问权限修饰符： private < 默认不写（注意不要添加default修饰）< protected < public private ：私有的 最小权限，被它修饰的成员只能够在本类中可以访问到；

public ：公共的 最大权限，任何地方和任何人都能访问；

4.测试：变量 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. 上面的代码把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;

}

}

• 封装小结

1. 封装的意识

2. 在Java 中的体现及步骤

1) 把类中的字段私有化；

2) 给每一个字段都提供一组getter setter方法 (方法的规范写法)；setXxx

在测试类中尝试创建对象,并通过调用getter setter方法完成 对字段的赋值和取值；

3) 提供一个无参数的构造方法

3. 思考:

1) 能否把一个字段的get 和set方法写成一个方法

i. 不可取（比如 当我只是取值的时候，还需要传入参数，这不好）

2) 一个类中的多个字段的赋值方法 写成一个方法

i. 不可取 耦合度太高(万一我们只想给某一个字段赋值)

3) 单一职能原则:功能最小化,不要想着一个方法写完所有的功能

4. 给对象的字段赋值 一共有哪些方式：

1) 直接访问字段赋值 标准java类 X 字段一般都会给私有化（私有化访问不到）；

2) 通过构造方法赋值 只能够创建对象的时候赋初始值；

上面的代码 不是把“小李”修改成“小李飞刀”，而是重新创建对象；

3) 通过setXxx方法赋值 更灵活；

setXxx 这么好是否就可以不要构造方法了呢？

两者不冲突，一般可以在创建的时候赋值，也可以后面进行修改

4) 字段必须私有化

5) 给每一个字段提供合理的getter setter方法

必须有一个公共的无参数的构造方法;

2.继承

• 继承概念的引入

1. 专业解释：

1) 泛华：在多个子类的基础上面抽取共有属性的行为到一个父类中去

2) 特化：在一个父类的基础上拓展子类特有的属性和行为，生成一个新的子类

3) 原则：父类存放共性，子类存放特性

2. 代码理解：

1) 三个类都有重复的代码，可以把这部分内容 抽出去，抽出去放到另外一个类里面；

a. 上面的类我们叫做 父类（超类，基类，根类）

2) 下面的3个类和上面的类需要发生一点关系【继承】

a. 下面的类我们叫做 子类（派生类，拓展类）

3. 提取好处 : 提高了代码的复用性

• Java中类继承的基本语法

1. Java类中的继承的语法格式: extends 父类

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

}

}

• 子类可以从父类继承哪些成员？

1. 思考 : 一个父类中可能有哪些? 字段 方法 构造方法

2. 访问权限有关 private public

3. 验证 :非私有的字段 和方法 可以被继承到（暂时这样记忆-主要是从是否可以访问的层面考虑）

4. 构造方法不能够被继承:java规定

5. 子类可以继承到父类的特性class MyFrame extends java.awt.Frame{}

class Person extends Animal{

Animal(){};

}

---------- Javac ----------

错误: 方法声明无效; 需要返回类型

• Java中类的继承特点

1. Java中类的继承只能够是单继承

2. 可以支持多重继承

3. 每一个类都有一个直接父类,如果没有看到显示的继承代码,那么就隐式继承就Object

• 继承总结

1. 继承的概念引入

2. 继承的基本语法

3. 继承到父类的那些东西

(1) 非私有的字段及方法

(2) 父类特性

4. 继承的特点

(1) 单继承

(2) 多重继承

(3) 没有显示的继承,那么隐式的继承Object

3.多态

• 多态的引入

1. 简单理解一种事物的多种形态

2. java代码中的体现

1) 一个人就是一个动物：Animal aml = new Person();//一个动物变量中，可能存放子类对象的多可能

2) 一个猪就是一个动物：Animal aml = new Pig();

3) 一个蛇就是一个动物：Animal aml = new Snak();

• 什么是多态

1.一个人就是一个动物：

(1) Animal aml = new Person();//一个动物变量中，可能存放子类对象的多种可能

2.理解：使用aml：编译是看的是Animal类型，运行时看的是实际存放的对象[真实类型]

3.官方概念：编译时跟运行时类型不一致就产生了多态

4.通俗理解：父类类型的变量，存放子类类型的对象，可能存放子类类型的对象有多种可能

5.多态存在的前提：必须有继承关系

• 多态方法调用编译运行过程[重点]

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. 没找到：向上到父类中找并执行

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

1. 父类中有一个方法,子类覆写了

2. 父类中有一个方法,子类没有

3. 父类中没有,子类有一个方法

4. 父类子类都没有

----------- 上面都是实例方法,下面来一个静态方法---------------------------------

5. 静态方法

6. 字段没有覆写一说

分析：

1. 实际开发中一般不会再子类中定义一个和父类同名的字段，

2. 如果是有这样的情况存在，

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. 多态的好处：屏蔽了不同子类之间实现的差异