Java面向对象的三大特性

面向对象的三大特性

Java面向对象编程作为一种编程思想，有三大特性，封装，继承，多态

Java 是面向对象的编程语言，对象就是面向对象程序设计的核心。所谓对象就是真实世界中的实体，对象与实体是一一对应的，也就是说现实世界中每一个实体都是一个对象，它是一种具体的概念。即万物皆对象。对象有以下特点：

• 对象具有属性和行为。
• 对象具有变化的状态。
• 对象具有唯一性。
• 对象都是某个类别的实例。
• 一切皆为对象，真实世界中的所有事物都可以视为对象。
• 类时对象的类型，对象是类的实例

1.封装

什么是封装:

封转是指属性私有化

• 根据需要提供setter和getter方法来访问属性
• 隐藏具体属性和实现细节，仅对外开放接口
• 控制程序中属性的访问级别

        简单的说，一个类就是一个封装了数据以及操作这些数据的代码的逻辑实体。在一个对象内部，某些代码或某些数据可以是私有的，不能被外界访问。通过这种方式，对象对内部数据提供了不同级别的保护，以防止程序中无关的部分意外的改变或错误的使用了对象的私有部分。

       就好比一个烤面包机，我们把面包（数据）放进去，按下开关，过了一会，它就会自动弹出烤好的面包（处理后的信息），而这个过程是怎么烤的（对数据的操作），我们是不需要知道的。

为什么需要封装：

隐藏一个类中不需要对外提供的实现细节；

属性的封装：使用者只能通过事先定制好的方法来访问数据，可以方便地加入逻辑控制，限制对属性的 不合理操作；

方法的封装：使用者按照既定的方式调用方法，不必关心方法的内部实现，便于使用； 便于修改，增强 代码的可维护性；

怎样实现封装：

利用权限修饰符来描述方法体或属性

访问修饰符：

修饰符	类内部	同一个包	子类	任何地方
private	✓
(默认)	✓	✓
protected	✓	✓	✓
public	✓	✓	✓	✓

public class User {
	private String admin;
	private String pwd;
	//获取admin的值调用该方法
	public String getAdmin() {
		return admin;
	}
	//设置admin的值时调用该方法
	public void setAdmin(String admin) {
		this.admin = admin;
	}
	//获取pwd的值调用该方法
	public String getPwd() {
		return pwd;
	}
	//设置pwd的值时调用该方法
	public void setPwd(String pwd) {
		this.pwd = pwd;
	}
}

封装说明一个类行为和属性与其他类的关系，低耦合，高内聚。

2.继承

- 什么是继承

继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力。

在本职上是特殊——一般的关系，即常说的is-a关系。子类继承父类，表明子类是一种特殊的父类，并且具有父类所不具有的一些属性或方法。从多种实现类中抽象出一个基类，使其具备多种实现类的共同特性 ，当实现类用extends关键字继承了基类（父类）后，实现类就具备了这些相同的属性。

继承性

如同生活中的子女继承父母拥有的所有财产，程序中的继承性是指子类拥有父类的全部特征和行为，这是类之间的一种关系。Java 只支持单继承。如图所示：

单继承就是一个子类只能有一个直接相关的父类，且只能继承访问权限非private属性和方法，然而一个父类可以有多个子类。子类可以重写父类中的方法，命名与父类中同名的属性，注意：重写父类中的方法时，如果父类方法有参数，子类在重写父类的该方法时参数列表必须与父类方法中的参数列表一样

继承的类叫做子类（派生类或者超类），被继承的类叫做父类（或者基类）。

如何实现继承： Java通过extends关键字来实现继承，父类中通过private定义的变量和方法不会被继承，不能在子类中直接操作父类通过private定义的变量以及方法。

/**
 1. 我是父类Student
 2. 我是子类XiaoMing
 3. 先打印的是父类里面的在打印的子类里面
 4. 从这个可以看出是先调用父类的构造方法创建父类对象再来调用子类里面的构造方法
   */
class Student{
 public Student(){
  System.out.println("我是父类Student");
 }
}
class XiaoMing extends Student{
 public XiaoMing(){
  System.out.println("我是子类XiaoMing ");
 }
}
public class InstanceDemo {
 public static void main(String[] args) {
  new XiaoMing();
 }
}

运行结果：
我是父类Student
我是子类XiaoMing

继承初始化顺序：
父类的构造器调用以及初始化过程一定在子类的前面
　　1. 初始化父类再初始化子类
　　2. 先执行初始化对象中属性，再执行构造方法中的初始化。
　基于上面两点，我们就知道实例化一个子类，java程序的执行顺序是：
　父类对象属性初始化---->父类对象构造方法---->子类对象属性初始化—>子类对象构造方法

3.多态

多态（Polymiorph）可以分为两种：设计时多态、运行时多态

设计（编译）时多态：即重载（Overload），是指java允许方法名相同而参数不同（返回值可以相同也可以不同），同一个类中允许存在一个或多个以上的同名函数，只要参数类型或参数个数不同即可

运行时多态：即重写（Override）必须是在继承体系中，子类重写父类方法，JVM运行时根据调用该方法的类型决定调用那个方法

public class main {
 
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		//分别将animal实例化成三种动物，
		
		Animal an = new Dog();
		an.cry();//根据每种动物自身的方法，自动选择内容
		an = new Cat();
		an.cry();
		an = new UnknowAnimal();
		an.cry();
	}
}
//基本类，包含一个基本方法
class Animal{
	public void cry(){
		System.out.println("我不知道自己是什么动物。");
	}
}
//声明子类，继承基本类，但有自己的方法
//实例化后优先使用自身的方法。
class Dog extends Animal{
	public void cry(){
		System.out.println("这是一条狗。");
	}
}
 
class Cat extends Animal{
	public void cry(){
		System.out.println("这是一只猫。");
	}
}
//这个子类自身没定义方法，实例化后会使用从父类继承来的方法
class UnknowAnimal extends Animal{
	
}

运行结果如下：
这是一条狗。
这是一只猫。
我不知道自己是什么动物。

java面向对象的五大原则

单一职责原则：一个类，最好只做一件事，只有一个引起它变化。每个类应该实现单一的职责，如果不是，那就把类拆分

开放封闭原则：对扩展开放，对修改封闭

里氏替换原则：子类必须能够替换其基类，里氏替换原则中说，任何基类可以出现的地方，子类一定可以出现

依赖倒置原则：依赖于抽象接口，不要依赖于具体实现，简单来说就是要求对抽象进行编程，不要对实现进行编程，这样就降低了客户于与实现模块间的耦合

接口隔离原则：使用多个小的专门接口，而不是使用一个大的接口