面向对象编程之继承、封装和多态

写在前面，java面向对象有三大特性，即封装、继承和多态。下面让我们逐一理解他们的内容。

封装

1.封装的概念

从字面上来理解就是讲内容藏起来，外部不可见，只保留一些接口来实现外部对内部的访问，在访问的时候不需要知道类内部的具体实现，只调用接口即可。
对于封装而言，一个对象它所封装的是自己的属性和方法，所以它是不需要依赖其他对象就可以完成自己的操作

2.使用封装的好处

1、良好的封装能够减少耦合。
2、类内部的结构可以自由修改。
3、可以对成员进行更精确的控制。
4、隐藏信息，实现细节。

3.案例

封装属性，将属性设为private类型，然后提供共有的getter和setter方法来间接访问

public class Person {
	private  String  name;
	private  int     age;
	private  String  sex;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		if(age>150||age<0) {
			return;
		}
		this.age = age;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}	
}

继承

1.继承的概念

概念：子类继承父类的方法和属性。
作用：提高代码重用性，建立类之间的关系（多态的前提）。
继承是使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但不能选择性地继承父类。通过使用继承我们能够非常方便地复用以前的代码，能够大大的提高开发的效率。

2.继承的特点

1、子类拥有父类非private的属性和方法。

2、子类可以拥有自己属性和方法，即子类可以对父类进行扩展。

3、子类可以用自己的方式实现父类的方法。（以后介绍）。

3.继承的范围

子类的继承范围如下

4.super关键字

第一种用法：
当子类的属性和重写的方法覆盖了父类继承的属性和方法，那么在子类中直接访问的是子类的属性和重写的方法。
如果想要在子类中，访问被覆盖的父类属性和方法，使用super来访问：
super.父类属性名
super.父类方法名(…)

注意：super不能用在类方法中。

第二种用法：
我们构建子类对象时，会先调用父类构造器添加继承的属性和方法，然后在调用子类构造器添加扩展的属性和方法、以及重写的方法。

我们调用的是哪个父类构造器呢？默认是父类无参构造器。
我们也可以指定调用父类的哪个构造器，使用super(实参)指定，这句话必须是子类构造器方法体中的第一句话。

5.方法重写

如果继承的父类方法无法满足子类的需求，那么可以在子类中对该方法重新定义，这叫方法的重写。

重写原则：
方法名相同，参数相同，返回值类型相同，访问修饰符范围>=父类的
一个小案例来体验一下继承的快乐
父类

public class father {
	public  String name;
	public int age;
	public father(int i) {
		System.out.println("父类");
	}
	public void run() {
		System.out.println("跑");
	} 
}

子类

public class son extends father{
	public son() {
		super(1);
		System.out.println("子类");
	}
	public void run() {
		super.run();
		System.out.println("我也跑");
	}
	public static void main(String[] args) {
		son son=new son();
		son.run();
	}
}

运行结果

多态

多态性，是面向对象中最重要的概念，在Java中的体现：
对象的多态性：父类的引用指向子类的对象
可以直接应用在抽象类和接口上
Java引用变量有两个类型：编译时类型和运行时类型。编译时类型由声明该变量时使用的类型决定，运行时类型由实际赋给该变量的对象决定。
简称：编译时，看左边；运行时，看右边。
若编译时类型和运行时类型不一致，就出现了对象的多态性(Polymorphism)
多态情况下，“看左边”：看的是父类的引用（父类中不具备子类特有的方法） “看右边”：看的是子类的对象（实际运行的是子类重写父类的方法）
对象的多态 —在Java中,子类的对象可以替代父类的对象使用
一个变量只能有一种确定的数据类型
一个引用类型变量可能指向(引用)多种不同类型的对象

Person p = new Student();
Object o = new Person();//Object类型的变量o，指向Person类型的对象
o = new Student(); //Object类型的变量o，指向Student类型的对象

子类可看做是特殊的父类，所以父类类型的引用可以指向子类的对象：向上转型(upcasting)。
实现多态的前提如下：

继承关系 方法的重写 向上转型

实现多态的案例

设计一个台灯类Lamp其中台灯有灯泡这个属性， 还有开灯(on)这个方法， 设计一个灯泡类Buble 其中有红灯泡(RedBuble)
和绿灯泡(GreenBuble) 他们都有一个发亮的方法，
请设计出一段代码可以使台灯开启灯泡发亮，并且保证替换不同种类的灯泡台灯类代码不被修改。

//台灯类Lamp
public class Lamp {
	private String buble;
	public Lamp() {
		
	}
	public String getBuble() {
		return buble;
	}

	public void setBuble(String buble) {
		this.buble = buble;
	}

	public void on() {
		System.out.println("开灯！！");
	}
}

//灯泡buble类
public class Buble extends Lamp{
	private String color;

	public Buble(String color) {
		this.color=color;
	}
	@Override
	public void on() {
		System.out.println(color+"灯泡亮了");
	}
}

//测试类
public class test {
	public static void liang(Lamp a) {
		a.on();
	}
	public static void main(String[] args) {
		Lamp aLamp=new Buble("红");
		liang(aLamp);
		Lamp aLamp1=new Buble("绿");
		liang(aLamp1);
	}
}