黑马程序员————java中面向对象的三大特性

------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

　　面向对象的思想是将一切事物看出由属性，方法，构造器，代码块，内部类等五个方面构成，只要事物在这五个方面有相似之处就可以归为一类，类与类之间则是通过封装，继承，多态来体现。

      首先说封装，很简单的思想，上帝创造我们出来没有给我们翅膀，那我们即使后天通过再大的努力也不可能会飞。这意味着虽然每一个类都具有高度可扩展性，你无法想法那些正在婴儿房躺着的孩子将来会不会是带领人类迁移地球的伟大科学家，你也不知道他们那个会是我们的下任主席，虽然略显夸张，但这些都是可以通过后天努力办到的，而长一双翅膀出来就是不可能的。所以如果你是上帝，你要创造一个物种在给他提供发展空间的同=时也必要为设置界限。通过封装就可以解决，设计个人类，在别人填写他的性别是我们当然希望他只能是“男”或"女"，你无法作出其他选项，也看不到为什么。用专业术语来讲就是把不想告诉别人的东西隐藏起来，把可以告诉别人的公开。其做法修改属性的访问权限来限制对属性的访问，并为每一个属性创建一对取值和赋值的方法，用于对这些属性的访问。

class Student{
	private String name;//私有修饰，只有本类才能访问
	private int age;
	private char gender;
	public void setGender(char gender){//为属性设置值
		if(gender=='男'||gender=='女'){
			this.gender=gender;
		}else{
			System.out.println("请输入正确的性别");
		}
	}
	public char getGender(){//提供一个可以访问的公共方法
		return this.gender;
	}
}
public class A6_12{
	public static void main(String[] args){
		Student one=new Student();
		one.setGender('f');
		System.out.println(one.getGender());
	}
}

　　值得一提的是private只是其中一种封装的手段，只要是访问不到的就叫做封装。

继承：

继承可以有效的简化代码，提高代码的复用性，也是因为有了继承才有了后面的多态。通过extends来绑定两者之间的关系。

Person{//父类，也可称为超类，基类
	String name;
	int age;
}
class Student extends Person{//继承了父类的属性
	void study(){
		System.out.println("学习");
	}
}
class Teather extends Person{//继承了父类的属性
	void teath(){
		System.out.println("教书");
	}
}

　　子类享有父类的成员，包括public，default，final，static所修饰的成员。在内存中随着子类对象的创建父类也会创建，那是因为子类隐含了一条super();语句

super（）;

　　那么如果对象访问其成员，到底是找父类中的呢还是找子类中的呢，这时候两个关键字就可以解决：

this.成员变量名       super.成员变量名

　　首先在没有关键字指引下，系统默认有this关键字先在子类中找，找不到再到父类中找，都找不到就报错。如果想越过子类直接找寻父类则通过super关键字即可。

子类继承父类最大的意义便是同过重写父类中的方法得到自己想要的。重写之前要有两个前提：1.方法权限必须大于等于父类权限 public>default>private  2.方法要一样，包括有无返回值，返回值也必须是父类返回值的子类，参数列表，方法名，抛出的异常也不能大于父类的异常。值得一提的是静态只能覆盖静态的。

class Animal{
	String Type;
	public void run(){
		System.out.println("跑步中");
	}	
}
class Cat extends Animal{
	
} 
class Dog extends Animal{ 
	public void run(String a){
		Type="大黄狗";
		System.out.println(Type+"哼着歌跑步中");
		
	}
	
}
public class A6_48{
	public static void main(String[] args){
		Cat C=new Cat();
		C.run();//因为子类没有方法，所以找寻父类的方法
		Dog d=new Dog();
		d.run();
		d.run("dd");
	}
}

　　

     子父类之间可以转型，默认向上转型，也就是子父可以之间转换为父类，如果父类转换为子类则需要强制转换，格式与基类型强制转换一致。强制转换前提是他们要有关系，通过instenceof关键字可以判断，返回boolean类型，true则存在继承关系，flase则无继承关系。

Anima instenceof Dog

　

多态：

　从四个方面来解释多态：1.多态的体现，父类引用指向子类对象；

                                  2.多态的前提，类与类之间必须要与继承，还要有重写；

                                  3.多态的好处，提高代码的课扩展性；

                                  4.多天的弊端，只能用父类中的引用访问父类中的成员。

例如，一个俄罗斯方块随机变形就是用的多态。

import java.util.Random;
class FK{//父类
	void bx(){//子类必要要重写父类的这个方法
		System.out.println("变形");
	}
}
class FK_szx extends FK{//山子型
	void bx(){
		System.out.println("山子型在变形");
	}
}
class FK_lzx extends FK {//L字型
	void bx(){
		System.out.println("L字型在变形");
	}
}
class FK_zzx extends FK{//Z字形
	void bx(){
		System.out.println("Z字型在变形");
	}
}
class FK_cfx extends FK{//长方形
	void bx(){
		System.out.println("长方型在变形");
	}
}
class FK_tzx extends FK{
	void bx(){
		System.out.println("田字型在变形");
	}
}
class A6_53{
	public static void main(String[] args){
		Random r=new Random();
		int a=r.nextInt(5);
		FK fk=null;
		switch(a){
		case 0:
			fk=new FK_szx();
			break;
		case 1:
			fk=new FK_lzx();
			break;
		case 2:
			fk=new FK_zzx();
			break;
		case 3:
			fk=new FK_cfx();
			break;
		case 4:
			fk=new FK_tzx();
			break;
		}
		fk.bx();//即父类引用指向子类对象
	}
}

　　值得一提的是在程序编译时参阅的是父类中的成员，运行时参阅的是子类中的成员，但是静态成员则是编译与运行都参考的是父类引用，因为他随类的加载就已经存在内存区了。