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

Ricardo_M_Zhou

于 2019-03-26 01:30:16 发布

阅读量158

点赞数

分类专栏： java 文章标签：面向对象三大特征封装、继承、多态

本文链接：https://blog.csdn.net/Ricardo_M_Zhou/article/details/88810502

版权

java 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

一、封装
1.下面的代码把name age 私有化 [提供private 修饰 ]之后就不能够操作了，
2. 怎么去赋值和取值呢？提供setget方法
3. 提供一个无参数的构造方法:标准的javaBean
如何控制程序中的访问？
通过给类中的成员（字段，方法，构造方法）添加访问权限来实现访问控制
3. 什么是访问权限：
例子：比如做一个系统，不同人登录进去，的访问权限不一样；
4. 访问权限修饰符： private < 默认不写（注意不要添加default修饰）< protected < public
private ：私有的最小权限，被它修饰的成员只能够在本类中可以访问到；
public ：公共的最大权限，任何地方和任何人都能访问；
5. 测试：变量 age是private修饰的（私有的）只能够在Student本类中可以被访问
6. 为什么需要将字段私有化起来：安全
5.3封装的步骤

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.继承的语法：
class A{}
class B extends A{}
B这个类继承到了A类
3.可以继承到父类的什么东西【一个类到底有什么东西可以继承到的】
考虑一个问题：假如父类有东西是私有化的private修饰的，私有化的，自己能访问

1.类
2.字段
3.普通方法
4.构造方法
.非私有的字段及普通方法是可以继承到的

Java中类的继承特点

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

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

	1.编译时，看的是父类类型，会现在父类中，看有不有对应的方法，如果没有继续向上找{更高父类}
	  如果找到了，编译通过，如果找不到，编译失败报错
	2.运行时：看真实类型，如果在真实类型中找到了，就运行真实类型中的函数，如果没有找到，向上找

	  问题：编译通过了，但是运行可不可能找不到？不可能的，因为编译都已经说明了
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();
	}
}

上面两句代码的编译,运行过程:

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

思考 : 有没有可能编译通过了,而运行找不到方法… 不可能!
3.4 编译时与运行时的几种情况分析
父类中有一个方法,子类覆写了
父类中有一个方法,子类没有
父类中没有,子类有一个方法
父类子类都没有
----------- 上面都是实例方法,下面来一个静态方法---------------------------------
静态方法
字段没有覆写一说
分析：
实际开发中一般不会再子类中定义一个和父类同名的字段，
如果是有这样的情况存在，

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

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 多态体现的几种情况

如上代码多态的体现的本质：都是父类类型的变量存放子类类型的对象
Dog dog = new XDog();//核心本质
方法参数传递：方法形参父类类型，允许传子类类型对象
i. Dog dog = new XDog();
ii. XDog xdog = new XDog();
iii. void feedDog(Dog dog){ }//此方法运行传递上面两个参数dog 或者 xdog : 本质传递的都是子类对象
方法返回值
Dog getDog(){//此方法返回值类型为父类类型Dog
return new XDog();//允许返回子类类型
}
多态的好处：屏蔽了不同子类之间实现的差异