八、面向对象的三大特性：封装，继承，多态

目录

1.封装

2.继承

2.1概述与应用

2.2不可继承性

2.3权限测试

2.4继承-重写(重点，难点)

2.5super与this的使用

3.多态

3.1多态核心

3.2多态直接引用

3.3多态以传参方式出现

3.4多态以返回值形式出现

4.例题

---

1.封装

//面向对象案例：车子的发动
//分析：   类： 车类       对象： new   属性：颜色，品牌等     方法：启动
//问题： 价格可以赋值为负数--程序逻辑没问题，但数据不合理
//解决方案：在程序中对属性的值进行判断是否大于0，如果小于0，则给定一个默认值即可
//封装性：不要使用属性直接赋值与取值，而是通过方法进行封装；该方法就是set/get方法
//好处：提高安全性及复用性
//封装性操作步骤：
//1.编写set/get方法
//2.属性私有化

class Car{
	private String brand;  //写上set和get   private:私有权限，限制属性只能在当前类中使用
	private  int    price;
	
	/*public void start() {
		System.out.println(brand+"品牌的汽车正在发动;价格为:"+price);
	}*/
	
	//set规范写法：set+属性名首字母大写,参数名与属性名一致
	public void setPrice(int price) {
		//注意：此处是为了说明封装特性，才进行的逻辑判断；后续没有特殊说明，则直接赋值
		if(price<0) {
			this.price = 100000;  //给定异常数据的默认值
		}else {
			this.price = price;
		}
	}
	
	//get规范写法: get+属性名首字母大写
	public int getPrice() {
		return price;  //可以+this吗？ 可以，只是get方法中没有冲突则可省略
	}
	
	public void setBrand(String brand) {
		this.brand = brand;
	}
	
	public String getBrand() {
		return brand;
	}
	
}

public class Test {
	public static void main(String[] args) {
		Car car = new Car();
		car.setBrand("路虎");
		car.setPrice(-1000);

		
		System.out.println("---------");
		
		//car.price = -10000;  //加权限限制--从源头上规避异常数据的录入
		car.setPrice(-10000);
		
		System.out.println(car.getPrice()+"==>"+car.getBrand());  //取值
	}
}

2.继承

2.1概述与应用

生活中的继承：施舍方的赠与，接受方的获取
程序中的继承：两个类之间满足“is a”的关系，这样的两个类，我们可以设置为继承
特点：有了继承关系，子类拥有父类的属性和方法

父类的选择：
在生活中满足is a关系的类很多，我们需要从中选择最合适的父类
例如： 狗类是动物类，也是生物类，也是物质类
       直接父类选择动物类---特征和行为最接近
结论： 重合点越多，越接近直接父类
       重合点越少，越接近Object类(祖宗类)

//继承的应用：
//案例： 子类有狗类，鸟类，找出他们的特征和行为
//狗类：  
//特征： [品种，姓名，年龄]，毛色
//行为： [吃，睡]，跑
//鱼类： [品种，姓名，年龄]
//特征： [吃，睡]，游

//父类：动物类--共性抽取，将所有子类共有的特征和行为放入父类，子类只需继承即可
//特征： 品种，姓名，年龄
//行为： 吃，睡

//作用：简化代码量，提高复用性

============================继承的共性抽取==========================

public class Animal {
	String brand;
	String name;
	int    age;
	
	public void eat() {
		System.out.println(name+"正在吃");
	}
	
	public void sleep() {
		System.out.println(name+"正在睡");
	}
}

//Dog类继承Animal类
class Dog extends Animal{
	String color;
	
	public void run() {
		System.out.println(name+"正在跑..");
	}
}

//Fish类继承Animal类
class Fish extends Animal{
	public void swim() {
		System.out.println(name+"正在游...");
	}
}

public class Test {
	public static void main(String[] args) {
		Dog dog = new Dog();  //实例化子类对象
		dog.name = "旺财";  //调用父类的特征
		dog.color = "黄色"; //调本类的特征
		
		dog.eat();    //调父类的行为
		dog.run();    //调本类的行为

		//匿名对象：没有名字的对象，只操作一次时，可直接new对象(匿名对象)调方法
		//new Animal().run();   //注意：父类不能调子类的特征和行为
	}
}

============================多级继承案例===========================

//细节：
//不能多继承(多个父亲)，但是可以多级继承(有父类，爷爷类，太爷爷类...)
//多级继承的特征和行为都可以叠加

//案例：
//爷爷拥有100万，父亲拥有一辆宝马车，儿子拥有一个奥特曼

class GrandFather{
	
	public void haveMoney() {
		System.out.println("拥有100万");
	}
}

class Father extends GrandFather{ //Son间接继承GrandFather
	public void haveCar() {
		System.out.println("拥有宝马车");
	}
}

class Son extends Father{ //Son直接继承Father
	public void havePeron() {
		System.out.println("拥有奥特曼");
	}
}

public class Test {
	public static void main(String[] args) {
		Son son = new Son();
		son.havePeron();  //调子类自身方法
		son.haveCar();    //调父类方法
		son.haveMoney();  //调间接父类方法
	}
}

2.2不可继承性

不可继承性：

        1. 父类私有的特征和行为不能被继承
        2. 构造方法不能被继承
        3. 在不同场景下的有些权限限制的特征和行为不能被继承(测试说明)

=========================不可继承性案例1========================
//不能被继承情况：
//1. 父类私有的特征和行为不能被继承
//2. 构造方法不能被继承-----最好测试带参构造

public class Person {
   private String name;  //私有属性
   
   public Person() {}
   
   public Person(String name) {
   }
}

class Student extends Person{

	public void study() {
		//System.out.println(name);  //私有权限，在子类中不能继承
	}
}

public class Test {
	public static void main(String[] args) {
		//父类有带参构造，子类没有，通过子类调父类带参构造，会报错；说明构造方法没有继承性
		//Student st = new Student("666");
 	}
}

2.3权限测试

权限测试：

        在java的面向对象案例中，主要权限有：priv