十三、java类的封装、继承、多态

面向对象的三个基本特性就是：封装、继承和多态。

前面讲解了java 程序都是由类文件组成的，java是面向对象的程序设计语言，在java中面向对象的思想就是由类的设计来体现的，也即类的继承、封装和多态。

一、封装(encapsulation)

封装性就是把类（对象）的属性和行为结合成一个独立的相同单位，并尽可能隐蔽类（对象）的内部细节，对外形成一个边界，只保留有限的对外接口使之与外部发生联系。封装的特性使得类（对象）以外的部分不能随意存取类（对象）的内部数据（属性），保证了程序和数据不受外部干扰且不被误用。

这个怎么理解呢？首先来看一个列子。

已知一个类Animal，该类的属性和方法如下表所示：

属性	说明	方法	说明
String name	名称	Animal()	无参构造函数，为属性设置初始值
Int age	年龄	Animal(String name,int age)	有参构造函数，为属性设置变量值

根据该类的定义，编写一个程序，输出该类的初始值以及通过变量设置的初始值，程序代码如下

public class AnimalDemo{

public static void main(Stringargs[]){

Animal a=new Animal();

Animal b=new Animal("cat",5);

System.out.println(a.name+"is "+a.age+" years old");

System.out.println(b.name+"is "+b.age+" years old");

}

程序执行结果：

Dog is 3 years old
cat is 5 years old

由此可以知道，类Animal的无参构造函数为name属性赋值为“Dog”，为age属性赋值为“3”。因此，可以写出类Animal的代码如下：

class Animal {
  String name;
  int age;
  Animal(){
   name="Dog";
   age=3;
  }
  Animal(Stringname,int age){
   this.name=name;
   this.age=age;
   }
}

实际上这就是上一篇文章中的例子，那么封装在这里的含义如下：

l 类本身就实现了封装功能，此处类Animal定义了两个属性，两个构造函数，其只属于Animal类。

l 通过访问修饰符来限制对类的属性和方法的访问，各修饰符含义如下：

Private:成员变量和方法只能在类内被访问，具有类可见性

默认：成员变量和方法只能被同一个包里的类访问，具有包可见性。

Protected：可以被同一个包中的类访问，被同一个项目中不同包中的子类访问

Public：可以被同一个项目中所有的类访问，具有项目可见性，这是最大的访问权限

l 只能通过类本身定义的方法来对该类所实例化的对象进行数据的访问和处理。比如想对实例化的对象添加其它的一个方法和属性是不可能的。这就体现的类的封装性。这里也可以理解一下为什么类被称之为模板或者蓝图。

二、继承

1、继承是面向对象的三大特征之一，也是实现代码复用的重要手段。Java的继承具有单继承的特点，即只能继承自一个父类，每个子类只有一个直接父类，但是其父类又可以继承于另一个类，从而实现了子类可以间接继承多个父类，但其本质上划分仍然是一个父类和子类的关系。

2、Java的继承通过extends关键字来实现，实现继承的类被称为子类，被继承的类称为父类(有的也称其为基类、超类)，父类和子类的关系，是一种一般和特殊的关系。就像是水果和苹果的关系，苹果继承了水果，苹果是水果的子类，水果是苹果的父类，则苹果是一种特殊的水果。

3、Java使用extends作为继承的关键字，extends关键字在英文是扩展的意思，而不是继承。为什么国内把extends翻译成继承呢？除了与历史原因有关外，把extends翻译成为继承也是有其道理的：子类扩展父类，将可以获得父类的全部属性和方法，这与汉语中得继承（子辈从父辈那里获得一笔财富成为继承）具有很好的类似性。

值得指出的是：Java的子类不能获得父类的构造器。

创建子类一般形式如下：

class 类名 extends 父类名{

子类体

}

4、子类与父类的变量、方法关系

子类可以继承父类的所有特性，但其可见性，由父类成员变量、方法的修饰符决定。对于被private修饰的类成员变量或方法，其子类是不可见的，也即不可访问；对于定义为默认访问（没有修饰符修饰）的类成员变量或方法，只有与父类同处于一个包中的子类可以访问；对于定义为public或protected 的类成员变量或方法，所有子类都可以访问。

子类中可以声明与父类同名的成员变量，这时父类的成员变量就被隐藏起来了，在子类中直接访问到的是子类中定义的成员变量。

子类中也可以声明与父类相同的成员方法，包括返回值类型、方法名、形式参数都应保持一致，称为方法的覆盖。

如果在子类中需要访问父类中定义的同名成员变量或方法，需要用的关键字super。Java中通过super来实现对被隐藏或被覆盖的父类成员的访问。super 的使用有三种情况：

l 访问父类被隐藏的成员变量和成员方法；

super.成员变量名;

l 调用父类中被覆盖的方法，如：

super.成员方法名([参数列]);

l 调用父类的构造函数，如：

super([参数列表]);

super( )只能在子类的构造函数中出现，并且永远都是位于子类构造函数中的第一条语句。

举例：

class BaseClass{

public double weight;

public void info(){

System.out.println("我的体重是"+weight+"千克");

}

public class ExtendsDemo001 extends BaseClass{

public static void main(String[]args) {

//创建ExtendsDemo001对象

ExtendsDemo001 ed = new ExtendsDemo001();

//ExtendsDemo001本身没有weight属性，但是ExtendsDemo001的父类有weight属性，也可以访问ExtendsDemo001对象的属性

ed.weight = 56;

//调用ExtendsDemo001对象的info()方法

ed.info();

}

举例二：

class Animal {

String name="animal";

int age;

void move(){

System.out.println("animalmove");

}

classDog extends Animal{

String name="dog"; //隐藏了父类的name属性;

float weight; //子类新增成员变量

void move(){ //覆盖了父类的方法move()

super.move(); //用super调用父类的方法

System.out.println("Dog Move");

}

publicclass InheritDemo{

public static void main(String args[]){

Dog d=new Dog();

d.age=5;

d.weight=6;

System.out.println(d.name+" is"+d.age+" years old");

System.out.println("weight:"+d.weight);

d.move();

}

程序运行结果：

dog is5 years old

weight:6.0

animalmove

DogMove

举例三：

classSuperClass {

SuperClass() {

System.out.println("调用父类无参构造函数");

}

SuperClass(int n) {

System.out.println("调用父类有参构造函数：" + n );

}

classSubClass extends SuperClass{

SubClass(int n) {

System.out.println("调用子类有参构造函数：" + n );

}

SubClass(){

super(200);

System.out.println("调用子类无参构造函数");

}

publicclass InheritDemo2{

public static void main(String arg[]) {

SubClass s1 = new SubClass();

SubClass s2 = new SubClass(100);

}

程序运行结果：

调用父类有参构造函数：200

调用子类无参构造函数

调用父类无参构造函数

调用子类有参构造函数：100

请自行分析程序运行的结果，体会继承的用法。

三、多态（Polymorphism）

多态性是指在继承关系中的父类中定义的属性或方法被子类继承之后，可以具有不同的数据类型或表现出不同的行为。这使得同一个属性或方法在父类及其各子类类中具有不同的含义。

Java引用变量有两个类型：一个是编译时类型，一个是运行时类型。编译时的类型由声明该变量时使用的类型决定，运行时的类型由实际赋给该变量的对象决定。如果编译时类型和运行时类型不一致，就会出现所谓的多态（Polymorphism）

举例1：

class Animal2 {

void eat(){

System.out.println("animal eat");

}

class Dog extends Animal2 {

void eat(){

System.out.println("Dog eat bone");

}

class Cat extends Animal2 {

void eat(){

System.out.println("Cat eat fish");

}

public class PloyDemo{

public static void main(String args[]){

Animal2 a;

a=newAnimal2 (); //编译时类型和运行时类型完全一样，因此不存在多态

a.eat();

a=new Dog(); //下面编译时类型和运行时类型不一样，多态发生

a.eat();

a=new Cat(); //下面编译时类型和运行时类型不一样，多态发生

a.eat();

}

程序运行结果：

animal eat

Dog eat bone

Cat eat fish

实例2：

class SuperClass{

public int book= 6;

public void base(){

System.out.println("父类的普通方法base()");

}

public void test(){

System.out.println("父类中将被子类覆盖的方法");

}

public class PloymorphismTest001 extends SuperClass{

//重新定义一个book实例属性，覆盖父类的book实例属性

public Stringbook = "Java疯狂讲义";

public void test(){

System.out.println("子类中覆盖父类的方法");

}

private void Dmeo() {

System.out.println("子类中普通的方法");

}

//主方法

public static void main(String[]args) {

//下面编译时类型和运行时类型完全一样，因此不存在多态

SuperClass sc = new SuperClass();

System.out.println("book1= "+sc.book);//打印结果为：6

//下面两次调用将执行SuperClass的方法

sc.base();

sc.test();

//下面编译时类型和运行时类型完全一样，因此不存在多态

PloymorphismTest001 pt = new PloymorphismTest001();

System.out.println("book2= "+pt.book);//打印结果为：Java疯狂讲义

//下面调用将执行从父类继承到的base方法

pt.base();

//下面调用将执行当前类的test方法

pt.test();

//下面编译时类型和运行时类型不一样，多态发生

SuperClass sscc = new PloymorphismTest001();

//结果表明访问的是父类属性

System.out.println("book3= "+sscc.book);//打印结果为：6

//下面调用将执行从父类继承到得base方法

sscc.base();

//下面调用将执行当前类的test方法

sscc.test();

//因为sscc的编译类型是SuperClass，SuperClass类没有提供Demo()方法

//所以下面代码编译时会出现错误

//sscc.Demo();

}

程序运行结果为：

book1=6

父类的普通方法base()

父类中将被子类覆盖的方法

book2=Java疯狂讲义

父类的普通方法base()

子类中覆盖父类的方法

book3=6

父类的普通方法base()

子类中覆盖父类的方法

十三、java类的封装、继承、多态相关推荐

python--编写程序：实现乐手弹奏乐器，乐手可以弹奏不同的乐器而发出不同的声音------使用类的封装继承多态的问题/使用面向对象的思想，设计自定义类，描述出租车和家用轿车的信息
编写程序:实现乐手弹奏乐器,乐手可以弹奏不同的乐器而发出不同的声音 ------使用类的封装继承多态的问题 class Instrumnet():#乐器类def make_sound(self):pa ...
类的封装继承多态以及virtual interface-SV
文章目录一.面向对象 1.1术语 1.2 三大特性和五大原则 1.3 验证为什么需要OOP 二.类和对象 2.1浅复制shallow copy 2.2 深复制(deep copy) 三.类的封装和继 ...
c语言编程菲薄拉,C语言设计模式-封装-继承-多态
快过年了,手头的工作慢慢也就少了,所以,研究技术的时间就多了很多时间,前些天在CSDN一博客看到有大牛在讨论C的设计模式,正好看到了,我也有兴趣转发,修改,研究一下. 记得读大学的时候,老师就告诉我们 ...
Java继承_Hachi君浅聊Java三大特性之封装继承多态
Hello,大家好~我是你们的Hachi君,一个来自某学院的资深java小白.最近利用暑假的时间,修得满腔java语言学习心得.今天小宇宙终于要爆发了,决定在知乎上来一场根本停不下来的Hachi君个人 ...
大数据笔记8—java基础篇4（面向对象-封装-继承-多态）
面向对象一.面向对象 1.面向过程 1.2.举例 1.3.总结二.面向对象 1.简述 2.举例 3.思想特点 2.1.类的定义格式 2.1.1.简述 2.2.2.格式 2.3.3.示例三.类的使 ...
Day55-每日一道Java面试题-Java 面向对象编程三大特性: 封装继承多态
Java 面向对象编程三大特性: 封装继承多态封装封装把一个对象的属性私有化,同时提供一些可以被外界访问的属性的方法,如果属性不想被外界访问,我们大可不必提供方法给外界访问.但是如果一个类没有 ...
python 参数类型的多态_【Python】面向对象：类与对象\封装\继承\多态
六.Python面向对象--类与对象\封装\继承\多态 1.什么是面向对象编程 1.1 程序设计的范式:程序可控,易于理解 1.2 抽象并建立对象模型 1.3 程序是不同对象相互调用的逻辑.每个对象在 ...
小白理解——封装继承多态
一.封装是什么:首先是抽象,把事物抽象成一个类,其次才是封装.对外表示为一个对象,隐藏对象的属性和动作实现的细节,仅对外公开接口. ...
白话文带你了解封装继承多态
这里讲的仅仅是带你理解封装继承多态染好您可以移步去别的文章学习具体的实现 (只是个人理解您可以不爱,请别伤害哦!) 首先你要知道 java是面向对象的,说白了就是我拿你当个人,请认清你的地位 ...
python多态的三种表现形式_python小结----面向对象的三大特征(封装,继承,多态)
面向对象的三大特征: 封装,继承,多态面向对象的编程思想核心:高类聚,低耦合–程序的设计模式范畴封装什么是封装: 在面向对象编程的思想中,对代码进行高度封装,封装又叫包装封装就是指将数据或者函 ...

十三、java类的封装、继承、多态

十三、java类的封装、继承、多态相关推荐

最新文章

热门文章