面向对象三大特性：继承、封装、多态

java面向对象三大特性

面向对象的优点体现在：与人类思维习惯一致；隐藏信息，提高了可维护性和安全性；提高了程序的可重用性。

一、继承

1、什么是继承？

在定义和实现一个类的时候，可以在一个已经存在的类的基础上来进行，把这个已经存在的类所定义的内容作为自己的内容，并可以加入若干新的内容，或修改原来的方法使之更适合特殊的需要，这就是继承。

继承是子类自动共享父类数据和方法的机制，这是类之间的一种关系，提高了软件的可重用性和可扩展性。

java中只支持单继承，也就是说一个类只能拥有一个父类。子类不能继承父类的构造方法。

java中所有的类都是由java.lang.Object类继承而来，Object是所有类的祖先类。

继承的关键字是：extends

2、继承条件下，构造方法的调用规则：

如果子类的构造方法中没有通过super显示调用父类的有参构造方法，也没有通过this显示调用自身的其他构造方法，则系统会默认先调用父类的无参构造方法；在这种情况下，有没有super();语句，效果都是一样的。

如果子类的构造方法中通过super显示调用父类的有参构造方法，则执行父类相应的构造方法，而不执行父类的无参构造方法。

如果子类的构造方法中通过this显示调用父类的有参构造方法，则在相应构造方法中应用以上两条规则。

特别注意的是：如果存在多级继承关系，则在创建一个子类对象时，以上规则会向更高一级父类应用，一直到执行顶级父类Object类的无参构造方法为止。

//使用继承前
class Student {
	public void eat() {
		System.out.println("吃饭");
	}
	
	public void sleep() {
		System.out.println("睡觉");
	}
}

class Teacher {
	public void eat() {
		System.out.println("吃饭");
	}
	
	public void sleep() {
		System.out.println("睡觉");
	}
}



//使用继承后，老师和学生都是人的范畴，抽取了老师和学生的共性功能，作为人的功能，让老师和学生去继承。
class Person {
	public void eat() {
		System.out.println("吃饭");
	}
	
	public void sleep() {
		System.out.println("睡觉");
	}
}


class Student extends Person {}

class Teacher extends Person {}


class ExtendsDemo {
	public static void main(String[] args) {
		Student s = new Student();
		s.eat();
		s.sleep();
		System.out.println("-------------");
		
		Teacher t = new Teacher();
		t.eat();
		t.sleep();
	}
}

3、super关键字：

super代表对当前对象的直接父类对象的默认引用。在子类中可以通过super关键字来访问父类的成员。

注意：

• super必须出现在子类（子类的方法或构造方法）中，而不是其他位置
• 可以访问父类的成员，如父类的属性、方法和构造方法
• 注意访问权限的控制，如无法通过super访问private成员

4、this关键字：

this关键字是对一个对象的默认引用，用来表示以后调用当前方法的对象的引用。

使用举例：

• 使用this调用成员变量，解决成员变量和局部变量的同名冲突
• 使用this调用成员方法
• 使用this调用重载的构造方法，只要在构造方法中使用，必须是构造方法的第一条语句

二、封装

1、什么是封装？

封装就是将类型的状态信息隐藏在类内部，不允许外部程序直接访问，而通过该类提供的方法类实现对象隐藏信息的操作和访问。

2、封装的好处：

隐藏类的实现细节；让使用者只能通过程序规定的方法来访问数据；可以加入存取控制语句，限制不合理操作。

/**
 *	封装和private的应用：
 *		A:把成员变量用private修饰
 *		B:提高对应的getXxx()和setXxx()方法
 */
 
//定义学生类
class Student {
	
	private String name;    //姓名
	private int age;        //年龄
	
	//姓名获取值
	public String getName() {
		return name;
	}
	
	//姓名设置值
	public void setName(String n) {
		name = n;
	}
	
	//年龄获取值
	public int getAge() {
		return age;
	}
	
	//年龄设置值
	public void setAge(int a) {
		age = a;
	}
}


//测试类
class StudentTest {
	public static void main(String[] args) {
	
		//创建学生对象
		Student s = new Student();
		
		//使用成员变量
		//错误：被私有修饰了，外界不能直接访问了
		//System.out.println(s.name+"---"+s.age);
		System.out.println(s.getName()+"---"+s.getAge());
		
		//给成员变量赋值
		//s.name = "张三";
		//s.age = 22;
		
		//通过方法给赋值
		s.setName("李四");
		s.setAge(22);
		System.out.println(s.getName()+"---"+s.getAge());
	}
}

三、多态

1、什么是多态？

多态就是同一个实现接口，使用不同的实例而执行不同的操作。

具体来说，多态是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定，即一个引用变量到底会指向哪个类的实例对象该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。因为在程序运行时才确定的类，这样，不用修改源程序代码，就可以让引用变量绑定到各种不同的类实现上，从而导致该引用调用的具体方法随之改变即不修改程序代码就可以改变程序运行时所绑定的具体代码，让程序可以选择多个运行状态，这就是多态性。

多态性增强了软件的灵活性和扩展性。

2、java中实现多态的机制是什么？

靠的是父类或接口定义的引用变量可以只想子类或具体实现类的实例对象，而程序调用的方法在运行期才动态绑定，就是引用变量所指向的具体实例对象的方法，也就是内存里正在运行的那个对象的方法，而不是引用变量的类中定义的方法。

3、多态的表现形式有哪些？

（1）重载overload

a、参数类型、个数、顺序至少有一个不相同。 
b、不能重载只有返回值不同的方法名。 
c、针对于一个类而言。 
d、不能通过访问权限、返回类型、抛出的异常进行重载； 
e、方法的异常类型和数目不会对重载造成影响；

（2）重写override

a、方法名、参数、返回值相同。 
b、子类方法不能缩小父类方法的访问权限，只能比父类的访问权限更大。 

c、子类方法不能扩大方法的异常范围，即只能比父类抛出更少的异常，或者是抛出父类抛出的异常的子异常，因为子类可以解决父类的一些问题，不能比父类有更多的问题。
d、存在于父类和子类之间。 
e、方法被定义为final不能被重写。 
f、被覆盖的方法不能为private，否则在其子类中只是新定义了一个方法，并没有对其进行覆盖。

/**
 *  多态————使用override实现
 */
class A extends Main{
	public String show(A obj)
	{
		System.out.println("调用了A的show方法");
		return "A";
	}
}
class B extends Main{
	public String show(B obj)
	{
		System.out.println("调用了B的show方法");
	return "B";
	}
}
class C extends A{
	public String show(C obj)
	{
		System.out.println("调用了C的show方法");
		return "C";
	}
}

public class Main{
	public static void main(String[] args)
	{
		Main u = new Main();
		A a = new A();
		B b = new B();
		C c = new C();
		System.out.println(u.show(c));//改变c的值为a，b，看结果
	}
	public String show(Main main)
	{
		if(main instanceof A)
		{
			System.out.println("以A类为对象调用show方法");
		}
		if(main instanceof B)
		{
			System.out.println("以B类为对象调用show方法");
		}
		if(main instanceof C)
		{
			System.out.println("以C类为对象调用show方法");
		}
		return "main";
	}
}

//其中A，B类是Main类的子类，C是A的子类，改变(u.show(c))的值。
//特别的，如果Main引用指向C对象，那么它同时也指向C对象的父类：A对象。
//所以结果是这样的：
//    以A类为对象调用show方法
//    以C类为对象调用show方法
//    main