黑马程序员-----------------面向对象_封装、继承、多态

android培训、java培训、期待与您交流！

面向对象语言具有三大特性封装、继承、多态

封装：何为封装，封装就是把不必要让外界访问的数据隐藏在一个类里面，对外提供一个公开的接口供外界使用。

封装的好处：将变化隔离、便于使用、提高重用性、提高安全性

封装原则：将不需要对外提供的内容都隐藏起来对外提供简洁的接口。

如何进行封装,以人为例子把人看作一个对象，人这个对象具有姓名，年龄两个属性，并具有一个speak行为

代码演示：

class Person
{
	String name;
	int age;
	void speak()
	{
		System.out.println(name+"今年"+age+"岁了。");
	}
}
public class PersonDemo {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//建立对象
		Person p =new Person();
		//访问对象里面的属性并赋值
		p.age =5;
		p.name ="leo";
		p.speak();
	}

}

从代码里可以看到，当建立了Person类对象以后，对象的引用直接访问对象里面的属性出现了安全隐患，为了提高安全性把不需要对外公开的数据利用

private修饰私有化封装在类里面，并提供对外访问的方式；并可以对访问方式中假如逻辑判断，对访问的数据进行操作，提高代码的健壮性。

利用封装检测年龄是否满18岁

代码演示：

class Person
{
	//私有化成员变量
	private String name;
	private int age;
	void speak()
	{
		System.out.println(name+"今年"+age+"岁了。");
	}
	//建立对外公共访问方法
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		//对访问的数据进行逻辑判断判断是否未成年
		//若访问数据小于18岁则打印未成年
		if(age>0){
			if(age<18&&age>0)
			{
				System.out.println("未成年");
			}
			this.age = age;
			speak();
		}else
			System.out.println("年龄不能为负数");
	}
}
public class PersonDemo {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//建立对象
		Person p =new Person();
		//访问对象里面的属性并赋值
		p.setAge(-1);
		p.setName("leo");
		//p.speak();
	}

}

从代码可以看出利用对象访问提供的公共方法很方便只需要传递相对应的参数。

p.setAge(-1);
p.setName("leo");

继承：是面向对象程序设计很重要的特性，在保留原来的功能并加以扩展，而且原来的程序代码可以重复使用不需要重新编写相同部分。

在Java中以现有类为基础，衍生出另一类，这就叫继承。现有的类即为父类或基类，衍生出的类叫子类或衍生类。

继承的好处：

1.提高代码的复用性。

2.让类与类之间产生了关系，有了这个关系就有了面向对象的另一个特性多态；

值得注意的一点是在类与类之间继承的时候，继承是抽取类之间共性的信息当子类继承了父类时，子类就能得到了父类所有的信息，

例如：

class ExtendsA
{
	void say(){};
	void run(){};
}
class ExtendsB
{
	void say(){};
	void jump(){};
}

当发现两个类具有共性内容时不要盲目的去继承；这时发现ExtendsA跟ExtendsB两个类都具有say()方法

class ExtendsA
{
	void say(){};
	void run(){};
}
class ExtendsB extends ExtendsA
{
	void say(){};
	void jump(){};
}

这时ExtendsB不仅具有了ExtendsA的say()方法同时也具有了run();但是ExtendsB并不希望有run()方法；就可以将共性内容抽取出来放到一个类里面作为父类 ExtendsA 

跟ExtendsB同时继承。

class Extends
{
	void say(){};
	
}
class ExtendsA extends Extends
{
	//void say(){};
	void run(){};
}
class ExtendsB extends Extends
{
	//void say(){};
	void jump(){};
}

这样两个子类就具有了父类的say()方法

在Java中不支持多继承，但是继承多层继承，因为在在多继承中多个父类具有相同的方法，子类对象就不知道该调用哪个父类的方法

不过在Java中可以利用接口的形式实现多继承的概念。

多态：即使某个事物具有多种形态的体现。

多态的体现：

父类的引用指向了自己的子类对象或者说父类可以接受子类的本类对象。

多态的前提：

必须是类与类之间有关系，要么继承，要么实现，存在覆盖。

abstract class Animal
{
	abstract void eat();
}
class Cat extends Animal
{
	public void eat()
	{
		System.out.println("吃鱼");
	}
	
}

class Dog  extends Animal
{
	public void eat()
	{
		System.out.println("吃骨头");
	}
}

猫狗同时继承了Animal类，都具有了eat方法，并有不一样的功能。

多态的好处：

多态的出现打打的提高了程序的扩展性

abstract class Animal
{
	abstract void eat();
}
class Cat extends Animal
{
	public void eat()
	{
		System.out.println("吃鱼");
	}
	
}

class Dog  extends Animal
{
	public void eat()
	{
		System.out.println("吃骨头");
	}
}
public class DuoTaiDemo {

	public static void main(String[] args) {
		//建立猫对象
		Cat c = new Cat();
		//c.eat();
		//Cat c1 = new Cat();
		//c1.eat();
		function(c);
		Dog d = new Dog();
		//d.eat();
		function(d);
		/*
		 	发现当创建一个不同的子类对象的时候需要再次狗血
		 	function方法。这是可以利用多态
		 */
		function(new Cat());
		function(new Dog());
		
	}
	
	public static void function(Animal a)
	{
		a.eat();
	}
	/*public static void function(Cat c)
	{
		c.eat();
	}
	public static void function(Dog d)
	{
		d.eat();
	}*/
}

从上面的代码可以看出，多态大大的减少了代码书写，代码的扩展性得到了增强。