Java_SE-封装-继承-多态(方法重写，接口)

封装

封装是为保护内部数据的安全，不希望外部类随意访问内部的成员变量

封装的步骤：

1. 私有化成员变量（用private修饰成员变量）
2. 为每一个成员变量提供合理的
   getXxx()方法 获取成员变量的值，如果当前成员变量类型是boolean类型，将getXxx()改为 isXxx()
   setXxx(…)方法 设置成员变量的值
3. 提供一个无参构造
4. 该类用public修饰

public class User {

	/**id*/
	private int id;
	
	/**姓名*/
	private String name;
	
	/**年龄*/
	private int age;
	
	/**VIP*/
	private boolean vip;
	
	/**
	 * 无参构造方法
	 */
	public User() {
		// TODO Auto-generated constructor stub
	}
	
	public User(int id,String name){
		
		this.id = id;
		this.name = name;
	}
	
	public User(int id,String name,int age,boolean vip){
		
		//在本类调用其他的构造方法
		this(id,name);
		//this解决成员变量和局部变量的二义性
		this.age = age;
		this.vip = vip;
	}

	public void setName(String name){
		this.name = name;
	}
	
	public String getName() {
		return name;
	}
	
	public void setId(int id) {
		this.id = id;
	}
	
	public int getId() {
		return id;
	}
	
	public void setAge(int age) {
		this.age = age;
	}
	
	public int getAge() {
		return age;
	}
	
	public void setVip(boolean vip) {
		this.vip = vip;
	}
	
	public boolean isVip() {
		return vip;
	}
}

继承

继承的作用：代码复用，提高开发效率和程序的扩展性。

继承语法：
class A{}
class B extends A{}

除了父类的构造方法其他的都能继承到子类

/**
 * 父类、AnimalExtends
 */
public class AnimalExtends {
	
	/**年龄*/
	private int age;
	
	/**名字*/
	private String name;
	
	/**
	 * 无参构造
	 */
	public AnimalExtends() {
		// TODO Auto-generated constructor stub
	}
	
	/**
	 * 有参构造
	 * @param age
	 * @param name
	 */
	public AnimalExtends(int age,String name){
		this.age = age;
		this.name = name;
	}
	
	public void setage(int age){
		this.age = age;
	}
	
	public int getage() {
		return age;
	}
	
	public void setname(String name) {
		this.name = name;
	}
	
	public String getname() {
		return name;
	}

	public void printEat() {
		System.out.println("吃...");
	}
}

/**
 * 子类、PersonExtends
 */
public class PersonExtends extends AnimalExtends{

	/**玩*/
	private String play;
	
	/**
	 * 无参构造
	 */
	public PersonExtends() {
		// TODO Auto-generated constructor stub
	}
	
	/**
	 * 有参构造
	 * @param play
	 */
	public PersonExtends(String play){
		this.play = play;
	}
	
	public void setPlay(String play) {
		this.play = play;
	}
	
	public String getPlay() {
		return play;
	}
	
	/**
	 * 方法重写
	 */
	@Override
	public void printEat() {
		System.out.println("名字："+getname()+" 年龄："+getage()+" 在吃：香蕉");
	}
	
	/**
	 * 特性
	 */
	public void printDo() {
		System.out.println(" 玩："+play);
	}

方法重写（override）

父类的方法，子类可以重写方法的方法体

以下注意事项了解即可：

1)重写只能出现在继承关系之中。当一个类继承它的父类方法时,都有机会重写该父类的方法。
 前提是父类的方法没有被被final（中文意思：最终的，以后讲）修饰
2)子类方法和父类方法的方法签名(方法名+参数列表)完全一致;
3)访问权限 : 子类方法的访问权限 大于等于父类方法的访问权限
4)static/private 方法不能够被重写 （java语法）
5)返回值类型 : 子类方法的返回值类型可以是父类方法的返回值类型的子类或者相等
6)子类抛出的异常（Exception）下是父类相应方法抛出的异常或者相等

接口

接口可以认为是一种特殊的类，但是定义类的时候使用 class 关键字，定义接口使用 interface 关键字。
接口中的方法都是公共的抽象方法

public interface 接口名{ 
抽象方法 1(); 
抽象方法 2(); 
抽象方法 2(); 
}

/**
 * 接口
 */
public interface IUser {

	/**
	 * 抽象方法，吃...
	 */
	void eat();
	
	/**
	 * 姓名
	 */
	void name();
}

接口的实现类通过implements实现接口

/**
 * 接口实现类
 */
public class UserImpl implements IUser {

	@Override
	public void eat() {
		System.out.println("吃猪肉！");

	}

	@Override
	public void name() {
		System.out.println("川宝");

	}

}

多态

向上造型/向上转型：
语法：
父类类型 父类变量 = new 子类类型();
父类变量.方法();//子类若重写，则会执行子类重写后的方法

//向上转型,Person转Animal,对象只能调用子类重写后的方法
Animal person = new Person();

//调用方法，子类重写后的方法
person.eat();

向下造型/向下转型： =>就是为了调用子类特有方法

//向下转型,对象能调用子类特有的方法
Person person2 = (Person)person;

//调用方法，子类特有的方法
person2.play();