面向对象编程

面向对象编程

---

封装

将属性和方法封装到一个类中。

比如宠物类

public class Pet {
	private String name;
	private int health;
	private int love;
	int num;
	
	public void print(){
		System.out.println("宠物的名字是："+name+"，健康值："+health+",亲密度："+love);
	}
}

将属性添加private修饰，即只允许本类方法中使用
其他类如果需要访问。需要通过get/set方法访问。

public class Pet {
	private String name;
	private int health;
	private int love;
	int num;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getHealth() {
		return health;
	}
	public void setHealth(int health) {
		this.health = health;
	}
	public int getLove() {
		return love;
	}
	public void setLove(int love) {
		this.love = love;
	}
	public void print(){
		System.out.println("宠物的名字是："+name+"，健康值："+health+",亲密度："+love);
	}
}

而get方法是用来获取属性值，set方法使用来设置属性值。

可通过点击"Source"菜单，选择"Generate Getters and Setters…"来生成get/set方法

封装的目的：将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问

---

继承

继承是代码重用的一种方式，将子类都有的属性和行为放到父类中

public class Dog extends Pet{
	private String strain;

	public String getStrain() {
		return strain;
	}

	public void setStrain(String strain) {
		this.strain = strain;
	}
	public void print(){
		super.print();
	}
	public static void main(String[] args) {
		Dog dog = new Dog();
		dog.print();
	}
}

当创建Dog类时，也需要name属性、health属性、love属性时，就可以使用继承，这样Dog类中也拥有Pet类的属性和方法。

当然Dog类中也可以拥有自己的属性和方法。
当子类的方法与父类的方法重名时，即子类重写了父类的方法

---

多态

同一种事物，由于条件不同，产生的结果也不同

如何实现多态？
1:子类要重写父类的方法
2: 父类类型作为形参类型
3: 实参传递子类的类型

public abstract class Pet {
	protected String name;
	protected int health;
	protected int love;
	public abstract void toHosiptal();
}

public class Dog extends Pet{
	private String strain;
	public void toHosiptal() {
		this.health += 60;
	}
}

public final class Penguin extends Pet{
	private String sex;
	public void toHosiptal() {
		this.health += 40;
	}
}

public class Master {
	public void Cure(Pet pet){
		pet.toHosiptal();
	}
	public static void main(String[] args) {
		Dog dog = new Dog();
		dog.health = 20;
		Penguin pen = new Penguin();
		pen.health = 30;
		Master mester = new Master();
		mester.Cure(dog);
		mester.Cure(pen);
	}

}

如上面4个类，分别是Pet类，Dog类，Penguin 类，Master类
其中Pet类中有抽象方法toHosiptal()，如果父类中存在抽象方法，子类必须重写这个抽象方法，所有Dog类和Penguin 类中也有toHosiptal()方法，并且有方法体。Dog类的方法体为:this.health += 60;Penguin类的方法体为:this.health += 40;,则表示不同宠物去医院一次Health值回复的不一致。

而在Master类中，有个Cure()方法,形参为Pet类对象。而在main方法中，可以看出传到Cure()方法的实参是Dog类和Penguin 类。

而程序并没有报错。运行的结果也是根据传入相应的对象，而执行相应类的方法，这就是多态。

根据不同事物的而实现不同的方法，尽管方法名相同，但是执行结果不一致，不同事物展示出得多种形态。

修饰符的访问权限。

修饰符	public	protected	default	private
同类	√	√	√	√
同包	√	√	√	×
子类	√	√	×	×
不同包	√	×	×	×

由此可见四种修饰符的权限排行：public > protected > default>private

---

static

即静态，

当static修饰属性，属性不再可被实例化对象调用。但是可以直接用类名调用

当static修饰方法，方法不再可被实例化对象调用。但是可以直接用类名调用

当static不能修饰类。

static {}为静态代码块，放置在里面的方法可以在加载后直接运行。主要是完成一些静态变量或静态常量的初始化工作。

在方法中不能定义static变量

不能在静态方法中引用非静态的属性和方法。可以在非静态方法中引用静态的方法和属性

---

abstract

即抽象

当abstract修饰类，该类为抽象类，不可被实例化

当abstract修饰方法，该方法为抽象方法，不能有方法体，而且修饰符必须时public 或者 protected，因为抽象方法没有方法体，所有必须要依赖子类重写。所有权限必须时public或protected，

如果子类也是抽象类，则不用重写父类的抽象方法。当子类也为抽象类时，就也无法实例化，故无法调用自身方法，所有不用重写

---

final

即最终

当final修饰属性，属性值不能被更改

当final修饰方法，方法不能被重写

当final修饰类时，类不能被继承

当final修饰引用类型时，不能再次被初始化(new)

final和abstract不能同时修饰类

实例化方法的执行顺序

按照之上的Master 类中实例化Dog方法，

首先执行父类的静态属性，然后执行子类的静态属性，再执行子类的构造方法，会隐式的调用父类的构造方法，然后执行父类的属性，继而执行子类的构造方法，执行子类的属性

父类的静态属性 —> 父类的静态代码块 —> 子类的静态属性 —> 子类的静态代码块 —> 父类的构造方法 —> 父类的属性 —> 子类的构造方法 —> 子类的属性

this和super

this：就是本类的意思
super:就是父类的意思。