Java小菜鸟的面试之路——面向对象的三大特征

1.继承 extends

子类继承父类，子类默认拥有父类的属性和方法（ps：父类的private属性不可继承，但可以通过父类封装的public方法获得）
举例：
Test1 有id，name等私有属性，id已封装（public），name不进行封装，还有protected addr 属性（不进行封装）

public class Test1 {
	
	private int id=4;
	private String name="zhangsan";
	protected String addr="南昌市";
	public int getId() {
		return id;
	}

Test2继承Test1类

public class Test2 extends Test1{
	
	private int age;
		
	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public String Methoad1(int num) {
		return "test";		
	}

	@Override
	public String toString() {
		return "Test2 [age=" + age + "]";
	}
	
}

在Test1的子类Test2中，可以通过父类Test1的public封装方法获取id的值，但无法获取name的值，因为它是父类的私有属性，且未进行封装

Test2 test2=new Test2();		
System.out.println(test2.addr);

但是可以直接调用父类的protected属性（public属性当然也可以）

2.封装

public class Test1 {
	
	private int id;
	private String name;
	
	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

将类的属性通过get ，set方法进行封装，保证了数据的安全性

Ps -> elipse默认快捷键：

get set 方法： alt+shift+s  +R 
toString 方法：alt+shift+s  +S 
全参构造函数：alt+shift+s  +O 
无参构造函数：alt+/ 

3.多态

多态是  同一个行为  具有  多个不同表现形式或形态  的能力；
多态就是  同一个接口 ，使用不同的实例而执行不同操作；

优点：

1. 消除类型之间的耦合关系
2. 可替换性
3. 可扩充性
4. 接口性
5. 灵活性
6. 简化性

必要条件：

1.继承
2.重写
3.父类引用指向子类对象

Ps：当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，再去调用子类的同名方法。

package dismiss;

public class Polymorphic {

public static void main(String[] args) {
	// TODO Auto-generated method stub
		
	show(new Cat());  //cat对象调用show方法  
	show(new Dog());  //dog对象调用show方法
	
	Animal animal=new Cat();  //使用Animal的引用实例化了一个Cat对象animal
	animal.eat();  //调用cat的eat方法
	Cat cat=(Cat) animal;  //Animal 没有work方法，只有强制转换陈Cat对象才能调用work函数
	cat.work();
	
}
public static void show(Animal a) {
	a.eat();
	if(a instanceof Cat) {
		Cat c=(Cat) a;
		c.work();			
	}else if(a instanceof Dog) {
		Dog d=(Dog) a;
		d.work();
	}
}

}

抽象父类Animal 有抽象方法eat()

abstract class Animal{
	public abstract void eat();	
	
	public void test() {
		System.out.println("123");
	}	
	//overload test 方法的重载——》参数类型、个数、顺序至少有一个不相同。 
	public void test(int num) {
		System.out.println("123");
	}
}

Cat类继承抽象父类Animal

class Cat extends Animal{  //继承抽象类需要重写，覆盖抽象父类的所有**抽象**方法

	@Override
	public void eat() {    //(重写，覆盖抽象父类的eat方法)
		// TODO Auto-generated method stub
		System.out.println("I like fish !");
	}
	public void work() {    // 	添加自己的方法work
		
		System.out.println("I can catch mouse !");
	}	
}

Dog 类继承抽象父类Animal

class Dog extends Animal{

	@Override
	public void eat() {  //(重写，覆盖抽象父类的eat方法)
		// TODO Auto-generated method stub
		System.out.println("I like bone");
	}
	public void work() {    // 	添加自己的方法work
		
		System.out.println("I can watch home !");
	}
}

rs：

I like fish !
I can catch mouse !
I like bone
I can watch home !
I like fish !
I can catch mouse !

尤其注意：重写override和重载overload 的区别
重载(overloading) 是在一个类里面，方法名字相同，而参数不同。
重写(Overriding)是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！

部分参考：http://www.runoob.com/java/java-polymorphism.html