
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.继承的特点

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

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

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

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

2.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 继承的演示

/
* *
 定义员工类Employee，做为父类
*/
 
class Employee {
    String name; // 定义name属性
   // 定义员工的工作方法
   public void work() {
 System.out.println("尽心尽力地工作");
}
} 
 
/
* *
定义讲师类Teacher 继承 员工类Employee
*/
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() {
// 访问父类中的num
System.out.println("Fu num=" + num);
// 访问子类中的num
System.out.println("Zi num=" + num);
}
} 
 
class ExtendsDemo03 {
public static void main(String[] args) {
// 创建子类对象
Zi z = new Zi();
// 调用子类中的show方法
z.show();
}
} 
 
演示结果：
Fu num = 6
Zi num = 6

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

class Zi extends Fu {
// Zi中的成员变量
int num = 6;
public void show() {
//访问父类中的num
System.out.println("Fu num=" + super.num);
//访问子类中的num
System.out.println("Zi num=" + this.num);
}
} 
 
演示结果：
Fu num = 5
Zi 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(){
//调用父类已经存在的功能使用super
super.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(Animal a)方法所替代
        而执行效果一致
        */
        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
        }
    }
}

六、总结

以上就是小编收集的关于java的封装、继承、多态的知识点了，有问题的地方欢迎评论交流呀，期待和各位一起变强呀！！！

原文链接：https://blog.csdn.net/wct040923/article/details/130528785

一、前言

二、封装

1.什么是封装？

2.封装的特点

3.封装的使用