Java面向对象三大特性

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了Java面向对象三大特性，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含13692字，纯文字阅读大概需要20分钟。

内容图文

封装

1. 封装概述

利用抽象数据类型将数据和基于数据的操作封装在一起，使其构成一个不可分割的独立实体。数据被保护在抽象数据类型的内部，尽可能地隐藏内部的细节，只保留一些对外接口使之与外部发生联系。用户无需知道对象内部的细节，但可以通过对象对外提供的接口来访问该对象。

2. 优点

减少耦合：可以独立地开发、测试、优化、使用、理解和修改
减轻维护的负担：可以更容易被程序员理解，并且在调试的时候可以不影响其他模块
有效地调节性能：可以通过剖析确定哪些模块影响了系统的性能
提高软件的可重用性
降低了构建大型系统的风险：即使整个系统不可用，但是这些独立的模块却有可能是可用的

3. 成员变量和局部变量的区别

区别成员变量局部变量在类中位置不同类中方法外方法内或者方法声明上在内存中位置不同堆内存栈内存声明周期不同随着对象存在而存在，随着对象消失而消失随着方法调用而存在，随着方法调用完毕而消失初始化值不同有默认的初始值没有默认的初始值，必须先定义，赋值，才能使用

注意：局部变量名可以和成员变量名一样，在方法中使用的时候，采用就近原则。

4. 类的初始化过程

以Student类为例：

public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

具体步骤：

加载Student.class文件进内存
在栈内存为s开辟空间
在堆内存为学生对象开辟空间
对学生成员变量进行默认初始化
对学生成员变量进行显示初始化
通过构造方法对学生对象的成员赋值
学生成员对象初始化完毕，将对象地址赋值给s变量。

封装:一个标准的手机类的代码及测试
手机类

public class SmartPhone {
    private String brand;
    private double price;
    private String color;

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public void call(String name){
        System.out.println("打电话给"+name);
    }

    public void sendMessage(String name){
        System.out.println("给"+name+"发短信");
    }

    public void playGame(){
        System.out.println("玩游戏");
    }
}

手机测试类1

public class SmartPhoneDemo {
    public static void main(String[] args) {
        SmartPhone sp=new SmartPhone();
        sp.setBrand("IPhone");
        sp.setPrice(6666);
        sp.setColor("白色");

        System.out.println("使用"+sp.getBrand()+"牌、售价为"+sp.getPrice()+"元的"
                +sp.getColor()+"的手机");
        sp.call("Jobs");
        sp.sendMessage("Kuke");
        sp.playGame();
    }
}

一个手机对象的内存简图：

Java面向对象三大特性 - 文章图片

手机测试类2

public class SmartPhoneDemo2 {
    public static void main(String[] args) {
        SmartPhone sp=new SmartPhone();
        sp.setBrand("IPhone");
        sp.setPrice(6666);
        sp.setColor("白色");

        System.out.println("使用"+sp.getBrand()+"牌、售价为"+sp.getPrice()+"元的"
                +sp.getColor()+"的手机");
        sp.call("Jobs");
        sp.sendMessage("Kuke");
        sp.playGame();

        SmartPhone sp2=new SmartPhone();
        sp2.setBrand("小米");
        sp2.setPrice(1000);
        sp2.setColor("黑色");

        SmartPhone sp3=sp;
        sp.setPrice(3555);
        System.out.println("使用"+sp.getBrand()+"牌、售价为"+sp.getPrice()+"元的"
                +sp.getColor()+"的手机");
    }
}

多个手机对象的内存简图：

Java面向对象三大特性 - 文章图片

5. 静态变量和成员变量的区别

区别静态变量成员变量所属不同属于类，所以也称为类变量属于对象，所以也称为实例变量（对象变量）内存中位置不同存储于方法区的静态区存储于堆内存内存中出现时间不同随着类的加载而加载，随着类的消失而消失随着对象的创建而存在，随着对象的消失而消失调用不同可以通过类名调用，也可以通过对象调用只能通过的对象来调用

6. 代码块

静态代码块：在类加载的时候就执行，且执行一次。一般用于对对象进行初始化。
构造代码块：每次调用构造方法都执行且在构造方法之前执行。一般是对类进行初始化。

执行顺序：

静态代码块---构造代码块---构造方法

public class CodeBlock {
    //构造方法
    CodeBlock(){
        int a=10;
        System.out.println(a);
    }

    //构造代码块
    {
        int a=100;
        System.out.println(a);
    }

    //静态代码块
    static {
        int a=1000;
        System.out.println(a);
    }

    public static void main(String[] args) {
        CodeBlock codeBlock=new CodeBlock();
    }
}

输出结果：

1000
100
10

继承

1. 继承概述

继承实现了 IS-A 关系，例如 Cat 和 Animal 就是一种 IS-A 关系，因此 Cat 可以继承自 Animal，从而获得 Animal 非 private 的属性和方法。

继承应该遵循里氏替换原则，子类对象必须能够替换掉所有父类对象。

Cat 可以当做 Animal 来使用，也就是说可以使用 Animal 引用 Cat 对象。父类引用指向子类对象称为向上转型。

Animal animal = new Cat();

2. 优点

提高了代码的复用性
提高了代码的维护性
在类与之间产生了关系，是多态的前提

3. Java中继承特点

Java只支持单继承，不支持多继承
Java支持多层继承

4. Java中继承注意事项

子类只能只能继承父类所有非私有成员（成员方法和成员变量）
子类不能继承父类的构造方法，但是可以通过super关键在去访问父类构造方法
不要为了部分功能而去继承
继承中类之间体现的是“is a”的关系。

5. 继承中成员变量的关系

子类中成员变量和父类中成员变量名称不同。
子类中成员变量和父类中成员变量名称相同。

在子类方法中的查找顺序：

在子类方法的局部范围找，有就使用

在子类的成员范围找，有就使用

在父类的成员范围找，有就使用

如果还找不到，就报错

6. 继承中构造方法的关系

子类中所有的构造方法默认会都会访问父类中空参数的构造方法

原因：因为子类会继承父类中的数据，可能还会使用父类的数据。所以，子类初始化之前，一定要完成父类数据的初始化。

每一个子类的构造方法第一条语句默认是：super();
如果父类中没有无参构造方法，该怎么办呢？

方式一：子类通过super去显示调用父类其他的带参的构造方法

方式二：子类通过this去调用本类的其他构造方法（子类一定要有一个去访问父类的构造方法，否则父类数据就没有初始化）

/**
* 1. 子类中所有的构造方法默认会都会访问父类中空参数的构造方法
* 2. 每一个子类的构造方法第一条语句默认是：super()
*/
class Father{
    public Father() {
        System.out.println("Father的无参构造函数");
    }
}

class Son extends Father{
    public Son() {
        //super();
        System.out.println("Son的无参构造函数");
    }
    public Son(String name) {
        //super();
        System.out.println("Son的带参构造函数");
    }
}

public class InheritanceDemo {
    public static void main(String[] args) {
        //使用无参构造函数初始化
        Son son=new Son();
        System.out.println("===========");
        //使用带参构造函数初始化
        Son son2=new Son("林青霞");
    }
}

输出结果：

Father的无参构造函数
Son的无参构造函数
===========
Father的无参构造函数
Son的带参构造函数
/**
 * 3. 如果父类中没有无参构造方法，该怎么办呢？

 方式一：子类通过super去显示调用父类其他的带参的构造方法

 方式二：子类通过this去调用本类的其他构造方法
 （子类一定要有一个去访问父类的构造方法，否则父类数据就没有初始化）
 */
class Parent{
    public Parent(String name){
        System.out.println("Parent的带参构造函数");
    }
}

class Child extends Parent{
    public Child() {
        //子类通过super去显示调用父类其他的带参的构造方法
        super("林青霞");
        System.out.println("Child的无参构造函数");
    }
    public Child(String name) {
        //方式一：子类通过super去显示调用父类其他的带参的构造方法
        //super(name);
        //方式二：子类通过this去调用本类的其他构造方法
        this();//嗲用Child()的无参构造函数
        System.out.println("Child的带参构造函数");
    }
}

public class InheritanceDemo2 {
    public static void main(String[] args) {
        Child c = new Child();
        System.out.println("==============");
        Child c2 = new Child("林青霞");
    }
}

输出结果：

Parent的带参构造函数
Child的无参构造函数
==============
Parent的带参构造函数
Child的无参构造函数
Child的带参构造函数

7.类中成员变量初始化

一个类的成员变量的初始化：

默认初始化
显式初始化
构造方法初始化

子类的初始化（分层初始化）

先进行父类的初始化，再进行子类的初始化

class X{
    Y b=new Y(); //显式初始化

    X(){
        System.out.println("X");
    }
}

class Y{
    Y(){
        System.out.println("Y");
    }
}

public class Z extends X{
    Y y=new Y();

    public Z() {
        super();//子类的初始化（分层初始化）:先进行父类的初始化，然后再进行子类的初始化。
        System.out.println("Z");
    }

    public static void main(String[] args) {
        new Z();
    }
}

输出结果：

Y
X
Y
Z

7. 继承中成员方法的关系

重写（Override）:子类和父类中出现了一模一样的方法声明

注意：

父类中私有成员方法不能被重写（因为父类中私有成员方法不能被继承）
子类重写父类中方法时，访问权限不能更低（最好一致）
父类是静态方法时，子类也必须通过静态方法进行重写。
子类和父类的声明最好一模一样。

8. final关键字

final关键字是最终的意思，可以修饰类，修饰变量，修饰成员方法

修饰类：不能被继承
修饰变量：变量就变成了常量，只能被赋值一次
修饰方法：方法不能被重写

注意：

final修饰局部变量

在方法内部，该变量不可以被改变

在方法声明上，分为基本类型和引用类型的情况

(1)基本类型：是值不能变

(2)引用类型：是地址不能变，但是该对象的堆内存中的值是可以改变的

final修饰变量的初始化时机

在对象构造完毕前即可（非静态常量）,被final修饰的变量只能赋值一次。

继承:一个标准的动物类、猫类、狗类的代码及测试
动物类

class Animal{
    private String name;
    private int age;
    private String color;

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public void eat(){
        System.out.print("吃什么东西？");
    }
}

猫类

class Cat extends Animal{
    @Override
    public void eat() {
        super.eat();
        System.out.println("猫粮");
    }

    public void play(){
        System.out.println("小猫在玩耍");
    }
}

狗类

class Dog extends Animal{
    @Override
    public void eat() {
        super.eat();
        System.out.println("狗粮");
    }

    public void bark(){
        System.out.println("小狗汪汪叫");
    }
}

测试

public class AnimalDemo {
    public static void main(String[] args) {
        Dog dog=new Dog();
        dog.setName("旺财");
        dog.setAge(12);
        dog.setColor("×××");
        System.out.println(dog.getName()+"\t"+dog.getAge()+"\t"+dog.getColor());
        dog.eat();
        dog.bark();

        Cat cat=new Cat();
        cat.setName("汤姆");
        cat.setAge(12);
        cat.setColor("蓝色");
        System.out.println(cat.getName()+"\t"+cat.getAge()+"\t"+cat.getColor());
        cat.eat();
        cat.play();
    }
}

多态

1. 多态概论

某一个事物，在不同时刻表现出来的不同状态。具体来讲，就是调用同一方法，会执行不同的功能。

实际生活：水在不同时刻的状态。

2. 多态分类

多态分为编译时多态和运行时多态：

编译时多态主要指方法的重载
运行时多态指程序中定义的对象引用所指向的具体类型在运行期间才确定

3. 运行时多态有三个条件

继承
覆盖（重写）
向上转型

4. 多态的好处和弊端

好处

提高了代码的维护性（由继承保证）

提高了程序的扩展性（由多态保证）

弊端

不能访问子类特有功能（特有方法）

如何访问子类中的特有功能？

方法一：将父类的引用强制转换为子类的引用，即向下转型
方法二：创建子类对象调用方法（可以，但是不合理，并且占内存）

/**
* 对象间的转型问题：
    向上转型：
        Parent f = new Child();
    向下转型：
        Child z = (Child)f; //要求该f必须是能够转换为Zi的。(父到子)
 */
class Parent {
    public void show() {
        System.out.println("show fu");
    }
}

class Child extends Parent {
    public void show() {
        System.out.println("show zi");
    }

    public void method() {
        System.out.println("method zi");
    }

}

public class PolymorphismDemo {
    public static void main(String[] args) {
         Parent fu=new Child();
        fu.show();
        //fu.method();//不能访问子类特有功能（特有方法）

        Child zi=(Child)fu; //向下转型
        zi.show();
        zi.method();
    }
}

输出结果：

show zi
show zi
method zi
class Animal {
    public void eat(){}
}

class Dog extends Animal {
    public void eat() {}

    public void lookDoor() {

    }
}

class Cat extends Animal {
    public void eat() {

    }

    public void playGame() {

    }
}

public class PolymorphismDemo3 {
    public static void main(String[] args) {
        //内存中的是狗
        Animal a = new Dog();
        Dog d = (Dog)a;

        //内存中是猫
        a = new Cat();
        Cat c = (Cat)a;

        //内存中是猫
        Dog dd = (Dog)a; //ClassCastException
    }
}

多态中对象内存图

Java面向对象三大特性 - 文章图片

5. 多态中的一些问题

/**
 * 多态中的成员访问特点：
     A:成员变量
        编译看左边，运行看左边。
    B:构造方法
         创建子类对象的时候，访问父类的构造方法，对父类的数据进行初始化。
    C:成员方法
        编译看左边，运行看右边。( 由于成员方法存在方法重写，所以它运行看右边。)
    D:静态方法
        编译看左边，运行看左边。(静态和类相关，算不上重写，所以，访问还是左边的)
 */
class Fu{
    public int num=100;

    public void show(){
        System.out.println("show function");
    }

    public static void function(){
        System.out.println("function Fu");
    }
}

class Zi extends Fu {
    public int num = 1000;
    public int num2 = 200;

    @Override
    public void show() {
        System.out.println("show Zi");
    }

    public void method() {
        System.out.println("method zi");
    }

    public static void function() {
        System.out.println("function Zi");
    }
}

public class PolymorphismDemo2 {
    public static void main(String[] args) {
        Fu f = new Zi();
        System.out.println(f.num);

        //System.out.println(f.num2);
        f.show();
        //找不到符号
        //f.method();
        f.function();
    }
}

输出结果：

100
show Zi
function Fu

免费Java高级资料需要自己领取，涵盖了Java、Redis、MongoDB、MySQL、Zookeeper、Spring Cloud、Dubbo高并发分布式等教程，一共30G。
传送门：https://mp.weixin.qq.com/s/JzddfH-7yNudmkjT0IRL8Q

内容总结

以上是互联网集市为您收集整理的Java面向对象三大特性全部内容，希望文章能够帮你解决Java面向对象三大特性所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/812240.html

来源：【匿名】

【上一篇】Java-Shiro：Shiro 【下一篇】JAVA/JSP学习系列之五

更多 ►

【Java面向对象三大特性】教程文章相关的互联网学习教程文章

面向对象思想，在java中，用到的是面向对象思想，而非c中面向过程，对象在现实生活中是客观存在的实物，例如人可以说成是一个对象，具有一定的特征（在我们设计中成为属性即成员变量），而人具有一定的动作，完成某些事情，在java中这便是方法，而对象我们可以暂认为是对某一事物的抽象，具体的操作便是抽象为一个Person类，其中有属性、有方法，这也体现了java语言都是围绕着生活和现实世界进行设计的，为了让人们在学习中更容易，...

Java面向对象（三）—— 继承【代码】

标签： java 继承抽象类 this super abstract概述多个类中存在相同的属性和行为的时候，将这些内容抽取到单独一个类中，那么多个类无需在定义这些属性和行为，只要继承那个类即可。多个类可以称为子类，单独这个类称为父类或者超类。子类可以直接访问父类中的菲斯有的属性和行为。通过 extends 关键字让类与类之间产生继承关系。 class SubDemo extends Demo{}继承的出现提高了代码的复用性集成的出现让类与类之间产生了关系，提供...

【java开发】面向对象初步认识与基础概念讲解

简单的把前面的java基础知识讲了，接下来就开始面向对象的旅程了。对象（Object）：简而言之，世界是由对象组成的，一切可见的事物吧类（class）：说白了就是把具有相同的一些特征或是属性归为一类对象具有的：静态特性：属性，变量等动态特性：方法，即函数简单的例子：把一个人当成对象，具有的属性有身高，性别，年龄等，具有的方法如吃饭，学习等；而人类就可以当成这个对象的类，java中class是类的关键字。上述描述可用java代...

java--面向对象【代码】

1. 定义类[修饰符] class 类名{零到多个构造器定义...零到多个成员变量...零到多个方法... }1.1 定义构造器[修饰符] 构造器名(形参列表){// 构造器名必须与类名相同// 由零到多条可执行语句组成 }2. 修饰符2.1 修饰符适用范围外部类/接口成员属性方法构造器初始化块成员内部类局部成员public√√√√ √ protected √√√ √ 包访问√√√√O√Oprivate √√ √ √ abstract√ √ √ final√√√ √√static √√ √√ strictf...

阿里云【名师课堂】Java面向对象开发65 ~ 67：抽象类的定义和使用【代码】【图】

目录65：抽象类基本概念66：抽象类使用限制（相关规定）1、抽象类中的构造1.1、父类中有无参构造时：1.2、父类中没有无参构造时：1.3、理解拓展：对象实例化操作的核心步骤2、抽象类中可不可以没有构造方法？3、抽象类不能使用final进行声明4、抽象类能不能被static定义？67：模版设计模式（抽象类的实际应用）首先，定义抽象的行为其次，定义各个行为的子类最后，调用各自的行为操作总结注意：在以后的开发过程中，绝大多数情况下...

Java面向对象作业-用接口方式测试向下转型【代码】

Java面向对象作业-用接口方式测试向下转型根据视频的里实例我们直接修改Test2测试方法： 1package com.java1234.chap03.sec13;2 3publicclass Test2 {4 5publicstaticvoid main(String[] args) {6 People p1=new Student();7 p1.say();8 9 Student student=(Student) p1; 10 student.say(); 1112 Teacher teacher=(Teacher) p1; 13 teacher.say(); 14 } 15 }运行报错：我是学生...

26. java面向对象 - static关键字【代码】

static可以修饰：属性、方法、代码块、内部类 static注意点：1.在静态方法内，不能使用this关键字、super关键字开发中，如何确定一个属性是否要声明为static？ >属性是可以被多个对象所共享的，不会随着对象的不同而不同开发中，如何确定一个方法是否要声明为static的？ >操作静态属性的方法，通常设置为static >工具类中的方法，习惯声明为static；比如：Math、Arrays、Collections/*** @ Author HuQi* @ Date 2020/1/30 20:52...

Java面向对象特性【图】

1.Java语言面向对象的三大关键特征1）封装：将对象的数据和操作数据的方法相结合，通过方法将对象的数据与实现细节保护起来，称为封装。在java中，通过类这种语言机制实现了数据的封装与隐藏。2）继承：当两个类有继承关系时，子类可以重用父类中的代码，如果想修改，就重写，继承关系减少了程序中相类似代码的重复说明。 java中只支持类之间的单继承，多重继承要通过接口实现。3.）多态：多态的含义可以表达为“对...

java面向对象-------static关键字，静态变量和普通变量区别【代码】

package java面向对象;/** * 测试static关键字 */public class TestStatic { /* 1、static修饰的成员变量和方法，从属于类，可以通过类直接调用。普通的变量和方法从属于对象 2、静态属性和方法是所有对象共享的，普通方法可以调用静态方法和属性，但静态方法不能调用普通的方法 */ static String name; int age; void say(){ sing();//可以随时调用 } static void sing(){...

对象序列化——Java面向对象基础(30)【代码】

1.对象序列化的目的：持久化对象数据2.对象序列化的条件：实现序列化的接口Serializableimport java.io.Serializable;publicclass MyObject implements Serializable{/*** 实现序列化接口，才能持久化*///serialVersionUID用于标识该类，系统自动生成privatestaticfinallong serialVersionUID = -765378581853551685L;private String nameOfObj;public String getNameOfObj() {return nameOfObj;}publicvoid setNameOfObj(String n...

JAVA面向对象

JAVA面向对象对象我们生活中能看到能摸到的一切事物都是对象。在程序中模拟出生活中的所有东西万物皆对象只要是对象——属性和行为（方法) 属性对象有什么例如:学生有姓名、学号、成绩、班级等。继承通过扩展一个已有的类，并继承该类的属性和行为，来创建一个新的类，已有的类为父类（基类，超类），新类为子类（派生类）。一个对象“有（has a）”一个属性，一个对象“执行（does）”一个行为。使...

Java面向对象学习笔记 -- 1(类、对象、构造器)【图】

1. 类 1）是同类型东西的概念，是对现实生活中事物的描述，映射到Java中描述就是class定义的类。 2）其实定义类，就是在描述事物，就是在定义属性（变量）和方法（函数）。 3）类中可以声明：属性，方法，构造器；属性就是实例变量，用于声明对象的结构的，在创建对象时候分配内存，每个对象有一份！实例变量(对象属性)在堆中分配，并作用于整个类中，实例变量有默认值，不初始化也能参与运算。 4）...

Java SE 第十六讲----面向对象特征之继承【代码】

1.继承（inheritance）：Java是单继承的，意味着一个类只能从另一个类继承（被继承的类叫做父类也叫【基类 baseclass】），继承的类叫做子类，java中的继承使用extends关键字。publicclass Child extends Parent{public Child(){System.out.println("child");} publicstaticvoid main(String[] args){Child child = new Child();} }publicclass Parent {public Parent(){System.out.println("Parent");} }输出结果：Parentchil...

《JavaScript》——面向对象与原型【图】

谈到面向对象，我们之前学过Vb和C#，从抽象到封装再到继承和多态，面向对象的世界真的很好玩，但是JavaScript中的面向对象有些特殊，因为里面没有类，而且对象的创建方式也不同。对象的创建大约有四种方式：使用new关键字创建、使用字面量创建、使用工厂方法创建、使用构造函数创建。 1、使用new关键字var box = new Object(); //创建一个 Object 对象 box.name = 'Lee'; //创建一个 name 属性并赋值 box.age = 100; //...

java面向对象类的继承~【代码】【图】

类的继承语法：修饰符 class 子类名 extends 父类名{ } 自定义类默认隐藏式继承了Object类 class Cat { ... } 等价于如下 class Cat extends Object{ ......... } 类的继承特性： 1、没指定继承哪个父类，默认继承Object 2、在Java中Object类是所有类的父类 3、子类继承父类时，不能继承父类的构造方法【这一点不如Python】 4、父类叫做基类，子类叫做派生类 ...

首页 / JAVA / Java面向对象三大特性

Java面向对象三大特性

内容导读

内容图文

封装

1. 封装概述

2. 优点

3. 成员变量和局部变量的区别

4. 类的初始化过程

5. 静态变量和成员变量的区别

6. 代码块

继承

1. 继承概述

2. 优点

3. Java中继承特点

4. Java中继承注意事项

5. 继承中成员变量的关系

6. 继承中构造方法的关系

7.类中成员变量初始化

7. 继承中成员方法的关系

8. final关键字

多态

1. 多态概论

2. 多态分类

3. 运行时多态有三个条件

4. 多态的好处和弊端

5. 多态中的一些问题

内容总结

内容备注

内容手机端

【Java面向对象三大特性】教程文章相关的互联网学习教程文章

JAVA - 相关标签

面向对象 - 相关标签

JAVA - 技术教程分类

JAVA - 最新教程

JAVA - 最热教程