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

封装

Java中的封装如何体现

如何控制程序中的访问？
通过给类中的成员（字段，方法，构造方法）添加访问权限来实现访问控制
什么是访问权限：
例子：比如做一个系统，不同人登录进去，的访问权限不一样；
访问权限修饰符：
private < 默认不写（注意不要添加default修饰）< protected < public
private ：私有的最小权限，被它修饰的成员只能够在本类中可以访问到；
public ：公共的最大权限，任何地方和任何人都能访问；

测试：变量 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 秒) - 正常终止

为什么需要将字段私有化起来：安全

封装的步骤

/*
	设计方法存值取值
		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;
	}
}

继承

继承的概念
专业解释：

泛华：在多个子类的基础上面抽取共有属性的行为到一个父类中去
特化：在一个父类的基础上拓展子类特有的属性和行为，生成一个新的子类
原则：父类存放共性，子类存放特性

代码理解：

三个类都有重复的代码，可以把这部分内容抽出去，抽出去放到另外一个类里面
上面的类我们叫做父类（超类，基类，根类）
下面的3个类和上面的类需要发生一点关系【继承】
下面的类我们叫做子类（派生类，拓展类）
提取好处 : 提高了代码的复用性

继承的基本语法
Java类中的继承的语法格式:

class Animal{}
class Person extends Animal{} //目标就是为了继承到Animal,这个类型
A 就是B的父类; B是A的子类
------------------------------------------------------------------------------
没有导包Arrays:
class Tools extends java.util.Arrays{ }
导包了Arrays
class Tools extends Arrays{ }

b.	验证:子类中是否可以继承到父类中的东西(通过创建子类对象来操作从父类继承的东西)
class Animal{
tring 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();
	}
}

继承父类的那些成员

非私有的字段和方法可以被继承到（暂时这样记忆-主要是从是否可以访问的层面考虑）
构造方法不能够被继承:java规定
子类可以继承到父类的特性

Java中的继承特定

Java中类的继承只能够是单继承
可以支持多重继承

多态

多态的概念

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

多态的编译时运行时过程

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编译时父类类型]
找到：编译通过
找不到：编译报错
注意：是不会向下找的[aml编译时子类类型]
运行时 :
先到运行时类型[Person]中找eat方法,
如果找到：就执行,
没找到：向上到父类中找并执行
思考 : 有没有可能编译通过了,而运行找不到方法… 不可能!

多态的应用示例

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

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

封装

继承

多态

猜你喜欢