2021-11-08

Java的封装 继承 和 多态

封装

定义：是指一种将抽象性函式接口的实现细节部分包装、隐藏起来的方法。
封装的意义：

1. 提高程序的安全性，保护数据
2. 隐藏代码的实现细节
3. 统一接口
4. 提升系统可维护性

//实例类
public class Person {
	 private String name ;  // private是私有的，只能在本类中调用使用
	 private int age;
	 private int wigth;
	 
    public String getName() {   //这个是共有的，可以调用接口在其他的类中使用,获取
		return name;
	}
	public void setName(String name) {  //共有的输出，和get配套使用
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public int getWigth() {
		return wigth;
	}
	public void setWigth(int wigth) {
		this.wigth = wigth;
	}
	//访问类
	public class Play {
	 public static void main(String[] args) {
		Person d = new Person();
		d.setName("小白鸽");
		d.setAge(7);
		d.setWigth(20);
		System.out.println("Name:"+ d.getName());
		System.out.println("Age:"+ d.getAge());
	}

属性类私有 使用get/set（记住哦）

继承

定义：继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。
继承的特点：

1. extends 表示继承
2. 继承只能是单继承，没有多继承。（就是说一个父亲可以有多个儿子，但是一个儿子只能有一个父亲）
3. 子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。
4. 子类和父类在意义上讲是“ is a”的关系
5. 没有继承的父类默认为 object。
   

//父类
public class Person {
	 public  String name ;  //只有公开的类才能被子类访问到
	 public int age;
	 public int wigth;
public void study() {
	 System.out.println(" person is like study");
 }  
}
//子类
public class Student extends  Person{
	public static void main(String[] args) {
		Person per = new Person();
		per.name = "小白";
		per.study();
		System.out.println(per.name);
	}

}

多态

定义：针对某个类型的方法的调用，其真正运行的方法取决于运行时期实际类型的方法。
多态的优点：

1. 可替换性
2. 可扩充性
3. 接口性
4. 灵活性
   多态存在的三个必要条件：
   继承
   重写
   父类引用指向子类对象：

//向上转型
Parent p = new Child();

//主类
public class Person {
public void study() {
	 System.out.println(" person is like study");
 }
 
    
}
//class1
public class Student extends  Person{  // 1.继承
	
	public static void main(String[] args) {
		Person poo = new Student(); // 3. 向上转型
		poo.study();
		
	}
	@Override   
	public void study() {  //2.重写(多态)
		 System.out.println(" student is like study");
	 } 
}
//class2
public class Friends extends Person {

	public static void main(String[] args) {
		Person pp = new Friends();
		pp.study();

	}
	//由此可见，person中的一个study方法可以重写很多遍，在不同的类中，
	//根据我们的需求的不同，动态的使用study类
	@Override   
	public void study() {  //重写
		 System.out.println(" friends is like study");
	 }
}