学习笔记---第8章类的封装，继承与多态（Java）

8.1封装

（1）封装的目的是提高安全性和简化编程
（2）Java访问权限修饰符一共有4种。

私有private
公有public
保护protected
默认default（没有修饰符）

（3）在面向对象编程法则里，用对象直接访问类中的属性是不允许的，为了避免这种情况发生，通常要将类中的属性封装，用关键词private声明为私有，从而保护起来。如果要给对象的属性赋值，则要获得这些私有属性的公共接口，这些接口的外在表现形式都是公有方法public。
通常，对属性值设置的方法命名为setXxx()，这类方法可统称为setter方法，获取属性值的方法被命名为getXxx()，这类方法可统称为getter方法。
举个例子：


class MyCat
{
	private float weight;
	private float height;   //初始化私有属性 weight 和 height
	public MyCat(float weight, float height)   //在构造函数中初始化私有变量
	{
		setWeight(weight);
		setHeight(height);    //调用私有方法设置 weight 和 height
	}
	//通过 private 修饰符，封装setWeight方法和setHeight方法
	private void setWeight(float wt)
	{
		if(wt > 0) {weight = wt;}
		else
		{
			System.out.println("weight设置非法（应该>0）.\n采用默认值10.");
			weight = 10.0f;
		}
	}
	private void setHeight(float ht)
	{
		if(ht > 0) {height = ht;}
		else
		{
			System.out.println("height设置非法（应该>0）.\n采用默认值20.");
			height = 20.0f;
		}
	}
	
	public float getWeight()     //创建公有方法getWeight()作为与外界通信的接口
	{return weight;}
	public float getHeight()
	{return height;}
}
public class TestEncapsulation 
{
	public static void main(String[] args) 
	{
		MyCat aCat = new MyCat(12, -5);
		float wt = aCat.getWeight();
		float ht = aCat.getHeight();
		System.out.println("The weight of the cat is: " + wt);
		System.out.println("The height of the cat is: " + ht);
	}
}

程序运行结果：

8.2继承

Java中继承的格式如下：
class 子类名 extends 父类名
继承的限制：

不允许多重继承，但可以多层继承，即C类不能同时继承A类和B类，但可以B类继承A类，C类再继承B类。
从父类继承的私有成员，不能被子类直接使用，必须通过设置Setter和Getter方法间接操作。
子类进行对象实例化时，从父类继承而来的数据成员需要先调用父类的构造方法来初始化，然后用子类的构造方法来初始化本地的数据成员。使用super关键字。
被final修饰的方法不能被子类覆写实例，被final修饰的类不能再被继承。

8.3覆写（属性覆盖）

即子类定义了和父类之中相同名称的属性（Override）。
super调用父类的方法：

class Person
{
	String name;
	int age;
	public String talk()
	{
		return "I am " + this.name + ", I am " + this.age + " years old.";
	}
}

class Student extends Person
{
	String school;
	public Student(String name, int age, String school)
	{
		this.name = name;    //super.name = name
		this.age = age;     //super.age = age
		this.school = school;
	}
	public String talk()      //此处覆写Person中的talk方法
	{   //通过super.talk()调用父类talk()方法
		return super.talk() + " I am from " + this.school + "."; 
	}
}
public class Override 
{
	public static void main(String[] args) 
	{
		Student s = new Student("Lyuwalle", 22, "TJ");
		System.out.println(s.talk());
	}
}

运行结果：
I am Lyuwalle, I am 22 years old. I am from TJ.

8.4多态

在Java中，多态性分为两类：（1）方法多态性，体现在方法的重载与覆写上。通过传递不同的参数来令同一方法接口实现不同的功能。（2）对象多态性，体现在父、子对象之间的转型上。这其中分为向上转型和向下转型，向上转型可以自动完成，向下转型必须进行强制类型转换。

class Animal
{
	public void move()
	{
		System.out.println("动物移动！");
	}
}
class Fish extends Animal
{
	public void move()    //覆写了父类的move()方法
	{
		System.out.println("鱼儿游！");
	}
}
class Bird extends Animal
{
	public void move()
	{
		System.out.println("鸟儿飞！");
	}
}
class Horse extends Animal
{
	public void move()
	{
		System.out.println("马儿跑！");
	}
}
public class ObjectPoly 
{
	public static void main(String[] args) 
	{
		Animal a;      //声明了一个父类对象a，但没有去实例化它
		Fish f = new Fish();
		Bird b = new Bird();
		Horse h = new Horse();
		a = f;  a.move();    
		//先通过赋值操作，将子类对象向上转型为Animal类型，再调用Fish()的move()方法，输出“鱼儿游！”
		a = b;  a.move();
		a = h;  a.move();
	}
}
//简单来说，继承是子类使用父类的方法，而多态则是父类使用子类的方法，更为确切地说，多态是父类使用被子类覆盖地同名方法。