public class Student {  private String name;  private int age; public void setName(String name) {    this.name = name;  }  public String getName() {    return name;  } public void setAge(int age) {    this.age = age;  }  public int getAge() {    return age;  }}

分析：对于上面的一个实体对象，我想大家都已经很熟悉了。将对象中的成员变量进行私有化，外部程序是无法访问的。但是我们对外提供了访问的方式，就是set和get方法。而对于这样一个实体对象，外部程序只有赋值和获取值的权限，是无法对内部进行修改，因此我们还可以在内部进行一些逻辑上的判断等，来完成我们业务上的需要。

三、继承

1.什么是继承？

继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。当然，如果在父类中拥有私有属性(private修饰)，则子类是不能被继承的。

2.继承的特点

1 只支持单继承，一个子类只允许有一个父类

2 子类可以拥有父类的属性和方法

3 子类可以拥有自己的属性和方法

4 子类可以重写父类的方法

5 可以声明父类，创建子类（又称作为父类装载子类）

例如：Person p=new Teacher();

(1) 声明什么样的类型，就只能调用什么类型的属性和方法

(2) 创建什么样的类型，就真正运行的什么类型的方法

提示： (1)和(2)称为向上转型，例如：Person p=new Teacher();那么p只能调用Person类中的方法和属性，但实际上运行的是Teacher中所重写的方法，无法调用Teacher中的私有的方法

(3) 创建什么样的类型，就可以强转为什么类型

提示：例如： Person p=new Teacher();

Teacher t=(Teacher) p;

这种叫做向下转型，此时t调用的是创建的Teacher类型的相应属性和方法。

3.继承的优点

提高代码发复用性
父类的属性方法可以用于子类
可以轻松定义子类
使设计应用程序变得简单

4.继承的使用

4.1 继承的格式

class 父类 {  ...}  class 子类 extends 父类 {...}

4.2 继承的演示

 class Employee {    String name; // 定义name属性   // 定义员工的工作方法   public void work() { System.out.println("尽心尽力地工作");}}  class Teacher extends Employee {// 定义一个打印name的方法public void printName() {System.out.println("name=" + name);  }}   public class ExtendDemo01 {public static void main(String[] args) {// 创建一个讲师类对象Teacher t = new Teacher();// 为该员工类的name属性进行赋值t.name = "小明";// 调用该员工的printName()方法t.printName(); // name = 小明// 调用Teacher类继承来的work()方法t.work(); // 尽心尽力地工作 }}

4.3 成员变量

当成员变量不重名时，对代码的访问是没有影响的，但是当成员的变量重名时，这个时候访问就会出现问题，例如：

class Fu {// Fu中的成员变量。int num = 5;}  class Zi extends Fu {// Zi中的成员变量int num = 6;public void show() {// 访问父类中的numSystem.out.println("Fu num=" + num);// 访问子类中的numSystem.out.println("Zi num=" + num);}}  class ExtendsDemo03 {public static void main(String[] args) {// 创建子类对象Zi z = new Zi();// 调用子类中的show方法z.show();}}  演示结果：Fu num = 6Zi num = 6

子父类中出现同名的成员变量时，在子类中访问父类中的非私有成员变量时，需要使用super关键字来修饰父类成员变量，类似于this。例如：

class Zi extends Fu {// Zi中的成员变量int num = 6;public void show() {//访问父类中的numSystem.out.println("Fu num=" + super.num);//访问子类中的numSystem.out.println("Zi num=" + this.num);}}  演示结果：Fu num = 5Zi num = 6

4.4 成员方法

当成员方法出现重名时，我们则需要用到方法重写（Override）。

方法重写：子类中出现与父类一模一样的方法时（返回值类型，方法名和参数列表都相同），会出现覆盖效果，也称为重写或者复写。声明不变，重新实现。

class Phone {public void sendMessage(){System.out.println("发短信");}  public void call(){System.out.println("打电话");} public void showNum(){System.out.println("来电显示号码"); }}//智能手机类class NewPhone extends Phone {//重写父类的来电显示号码功能，并增加自己的显示姓名和图片功能public void showNum(){//调用父类已经存在的功能使用supersuper.showNum();//增加自己特有显示姓名和图片功能System.out.println("显示来电姓名");System.out.println("显示头像");}} public class ExtendsDemo06 {public static void main(String[] args) {// 创建子类对象NewPhone np = new NewPhone()；// 调用父类继承而来的方法np.call();// 调用子类重写的方法np.showNum();}}

注意：这里在重写时，用到了super.父类成员方法，表示调用父类成员的方法。

4.5 构造方法

        首先我们要回忆两个事情，构造方法的定义格式和作用。
        1. 构造方法的名字是与类名一致的。所以子类是无法继承父类构造方法的。
        2. 构造方法的作用是初始化成员变量的。所以子类的初始化过程中，必须先执行父类的初始化动作。子类的构造方法中默认有一个 super() ，表示调用父类的构造方法，父类成员变量初始化后，才可以给子类使用。

class Fu { private int n; Fu(){  System.out.println("Fu()");  }} class Zi extends Fu {  Zi(){ // super（），调用父类构造方法  super();  System.out.println("Zi（）");  }} public class ExtendsDemo07{  public static void main (String args[]){  Zi zi = new Zi();  }} 输出结果：Fu（）Zi（）

五、多态

1.什么是多态？

多态是同一个行为具有多个不同表现形式或形态的能力。

2.多态的特点

消除类型之间的耦合关系，实现低耦合
灵活性
可扩充性
可替换性

3.多态的使用

多态体现的格式：

父类类型变量名 = new 子类对象；
变量名.方法名();

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，执行的是子类重写后方法。

定义父类：

public abstract class Animal {    public 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 Test {    public static void main(String[] args) {        // 多态形式，创建对象        Cat c = new Cat();        Dog d = new Dog();        // 调用showCatEat        showCatEat(c);        // 调用showDogEat        showDogEat(d);                showAnimalEat(c);        showAnimalEat(d);    }    public static void showCatEat (Cat c){        c.eat();    }     public static void showDogEat (Dog d){        d.eat();    }     public static void showAnimalEat (Animal a){        a.eat();    }}

        由于多态特性的支持，showAnimalEat方法的Animal类型，是Cat和Dog的父类类型，父类类型接收子类对象，当然可以把Cat对象和Dog对象，传递给方法。
        当eat方法执行时，多态规定，执行的是子类重写的方法，那么效果自然与showCatEat、showDogEat方法一致，所以showAnimalEat完全可以替代以上两方法。
        不仅仅是替代，在扩展性方面，无论之后再多的子类出现，我们都不需要编写showXxxEat方法了，直接使用showAnimalEat都可以完成。
        所以，多态的好处，体现在，可以使程序编写的更简单，并有良好的扩展。

4.引用类型转型

多态的转型分为向上转型与向下转型两种：
向上转型：多态本身是子类类型向父类类型向上转换的过程，这个过程是默认的。当父类引用指向一个子类对象时，便是向上转型。
使用格式

父类类型变量名 = new 子类类型();
如：Animal a = new Cat();

向下转型：父类类型向子类类型向下转换的过程，这个过程是强制的。
一个已经向上转型的子类对象，将父类引用转为子类引用，可以使用强制类型转换的格式，便是向下转型。
使用格式：

子类类型变量名 = (子类类型) 父类变量名;
如:Cat c =(Cat) a;

5.为什么要做转型？

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误。也就是说，不能调用子类拥有，而父类没有的方法。编译都错误，更别说运行了。这也是多态给我们带来的一点"小麻烦"。所以，想要调用子类特有的方法，必须做向下转型。

定义类：

abstract class Animal {    abstract void eat();}  class Cat extends Animal {    public void eat() {        System.out.println("吃鱼");     }     public void catchMouse() {        System.out.println("抓老鼠");    }} class Dog extends Animal {    public void eat() {        System.out.println("吃骨头");    }    public void watchHouse() {        System.out.println("看家");    }}

定义测试类：

public class Test {    public static void main(String[] args) {        // 向上转型        Animal a = new Cat();        a.eat(); // 调用的是 Cat 的 eat        // 向下转型        Cat c = (Cat)a;        c.catchMouse(); // 调用的是 Cat 的 catchMouse    }}

注意：此处在转换时，有时会出现转换异常的情况，例如：

public class Test {    public static void main(String[] args) {        // 向上转型        Animal a = new Cat();        a.eat(); // 调用的是 Cat 的 eat        // 向下转型        Dog d = (Dog)a;        d.watchHouse(); // 调用的是 Dog 的 watchHouse 【运行报错】    }}

这是因为，明明创建了Cat类型对象，运行时，当然不能转换成Dog对象的。这两个类型并没有任何继承关系，不符合类型转换的定义。为了避免ClassCastException的发生，Java提供了 instanceof 关键字，给引用变量做类型的校验，格式如下：

变量名 instanceof 数据类型
如果变量属于该数据类型，返回true。
如果变量不属于该数据类型，返回false。

所以在转换前我们可以先做一个判断

public class Test {    public static void main(String[] args) {        // 向上转型        Animal a = new Cat();        a.eat(); // 调用的是 Cat 的 eat        // 向下转型        if (a instanceof Cat){            Cat c = (Cat)a;            c.catchMouse(); // 调用的是 Cat 的 catchMouse        } else if (a instanceof Dog){            Dog d = (Dog)a;            d.watchHouse(); // 调用的是 Dog 的 watchHouse        }    }}