黑马程序员_java基础笔记(03)...面向对象

青旅半醒 2021-11-26 15:16 335阅读 0赞

——————————  ASP.Net+Android+IOS开发、.Net培训、期待与您交流！——————————

1：面向对象的概念，2 ： 类和对象的关系，3 ： 封装，4 ： 构造函数，5 ： this关键字，6 ： static关键字，

7 ： 单例设计模式，8 ： 继承，9 ： 抽象类，10 ： 接口，11 ： 多态，12 ： Object类，13 ： 内部类，

14 ： 异常，15 ： 包

**1:面向对象的概念**

理解

a:面向对象是相对面向过程而言

b:面向对象和面向过程都 是一种思想

c:面向过程

——强调的是功能行为

d:面向对象

——将功能封装进对象，强调具备了功能的对象。

e:面向对象是基于面向过程的。

面向对象： **三个特征：** **封装**(encapsulation) **，继承**(inheritance) **，多态**(polymorphism)

开发：其实就是 找对象，建立对象，使用对象。维护对象的关系。

**2:类与对象的关系**

**　　类：**对现实生活中事物的描述。

**　　对象**：这类事物，实实在在存在个体。

在内存中的位置：

成员变量：在堆内存中，因为对象的存在，才在内存中存在。

局部变量：存在栈内存中。

**　　匿名对象**

**　　　　**匿名对象使用方式一：对象的 **方法只调用一次**时，可以用匿名对象来完成，这样写比较简化。如果一个对象进行多个成员调用，必须给这个对象起个名字。

**　　　　**匿名对象使用方式二：可以将匿名对象作为实际参数进行传递。

**3:封装（Encapsulation）**

a:封装：是指隐藏对象的属性和现实细节，仅对外提供公共访问方式。

b:好处：将变化隔离，便于使用，提高重要性，提高安全性

c:封装原则：将不需要对外提供的内容都隐藏起来。把属性都隐藏， **提供公共方法对其访问。**

之所以对外提供访问方式，就因为可以在访问方式中加入逻辑判断等语句。对访问的数据进行操作。提高代码健壮性。

**　　private :私有**，权限修饰符：用于修饰类中的成员(成员变量，成员函数)。 私有只在本类中有效。私有仅仅是封装的一种表现形式。类中的属性通常被私有化，并对外提供公共的访问方法。这样可以避免安全隐患。这个方法一般有两个，规范写法： 对于属性 xxx，可以使用setXxx(),getXxx()对其进行操作。

**4:构造函数**

特点：

a:函数名与类名相同

b:不用定义返回值类型

c:不可以写return语句

**　　作用：**给对象进行初始化。

注意：

多个构造函数是以重载的形式存在的，当一个类中没有定义构造函数时，那么系统会默认给该类加入一个空参数的构造函数。当在类中自定义了构造函数后，默认的构造函数就没有了。

**　　构造函数和一般函数在写法上有不同。在运行上也有不同。**

构造函数是在对象一建立就运行。给对象初始化。而一般方法是对象调用才执行，是给对象添加对象具备的功能。一个对象建立，构造函数只运行一次。而一般方法可以被该对象调用多次。

**　　什么时候定义构造函数呢？**

当分析事物时，该事物存在具备一些特性或者行为，那么将这些内容定义在构造函数中。

**　　构造代码块**

作用：给对象进行初始化。对象一建立就运行，而且优先于构造函数执行。

和构造函数的区别：

构造代码块是给所有对象进行统一初始化，而构造函数是给对应的对象初始化。

构造代码块中定义的是不同对象共性的初始化内容。

Person p = new Person();

该句话都做了什么事情？

1，因为new用到了Person.class.所以会先找到Person.class文件并加载到内存中。

2，执行该类中的static代码块，如果有的话，给Person.class类进行初始化。

3，在堆内存中开辟空间，分配内存地址。

4，在堆内存中建立对象的特有属性。并进行默认初始化。

5，对属性进行显示初始化。

6，对对象进行构造代码块初始化。

7，对对象进行对应的构造函数初始化。

8，将内存地址付给栈内存中的p变量。

**5:this关键字**

**t** **his代表它所在函数所属对象的引用**，哪个对象在调用this所在的函数，this就代表哪个对象。

this的应用：当定义类中功能时，该函数内部要用到调用该函数的对象时，这时用this来表示这个对象。

**但凡本类功能内部使用了本类对象，都用this表示**。

this语句 :用于构造函数之间进行互相调用。this语句只能定义在构造函数的第一行。因为初始化要先执行。

public static void main(String\[\] args)

主函数：是一个特殊的函数。作为程序的入口，可以被jvm调用。

主函数的定义：

public：代表着该函数访问权限是最大的。

static：代表主函数随着类的加载就已经存在了。

void：主函数没有具体的返回值。

main：不是关键字，但是是一个特殊的单词，可以被jvm识别。

（String\[\] arr）:函数的参数，参数类型是一个数组，该数组中的元素是字符串。字符串类型的数组。

主函数是固定格式的：jvm识别。

jvm在调用主函数时，传入的是new String\[0\];

**6.static关键字**

static关键字： **用于修饰成员**（成员变量和成员函数）

被修饰后的成员具备以下 **特点**： **1:** **随着类的加载而加载，2:优先于对象存在，3:被所有对象所共享，4:可以直接被类名调用**

**　　使用注意**： **静态方法只能访问静态成员.静态方法中不可以写this，super关键字.主函数是静态的**

static **用法**：是一个修饰符，用于修饰成员(成员变量，成员函数).

当成员被静态修饰后，就多了一个调用方式，除了可以被对象调用外，  还可以直接被类名调用。 **类名.静态成员**。

实例变量和类变量的区别：

1，存放位置。类变量随着类的加载而存在于方法区中。实例变量随着对象的建立而存在于堆内存中。

2，生命周期：类变量生命周期最长，随着类的消失而消失。实例变量生命周期随着对象的消失而消失。

利处：对对象的共享数据进行单独空间的存储，节省空间。没有必要每一个对象中都存储一份。 可以直接被类名调用。

弊端：生命周期过长。 访问出现局限性。(静态虽好，只能访问静态。)

应用：构造函数需要私有化

函数被静态修饰被提供外界使用

**　　静态代码块。**

格式：

static\{

静态代码块中的执行语句。

特点：随着类的加载而执行，只执行一次,并优先于主函数。 用于给类进行初始化的。

静态代码块、构造代码块、构造函数同时存在时的执行顺序：静态代码块——> 构造代码块——>构造函数；

**　　生成Java帮助文档：命令格式：javadoc –df:\\ myhelp –auther –version ArrayTool.java**

**　　—d当前目录 　　—df:\\存到f:\\下　　   ArrayTool必须public修饰**

例： /\*\*

这是一个可以对数组进行操作的工具类，该类中提供了，获取最值，排序等功能。

@author 张三

@version V1.1

\*/

public class ArrayTool \{

/\*\* 空参数构造函数。 \*/

private ArrayTool()\{\}

/\*\* 获取一个整形数组中的最大值。

@param arr 接收一个int类型的数组。

@return 会返回一个该数组中最大值。 \*/

public static int getMax(int\[\] arr) \{

int max = 0;

for(int x=1; x<arr.length; x++) \{

if(arr\[x\]>arr\[max\]) max = x;

return arr\[max\];

**7:单例设计模式**

**　　设计模式的分类**

总体来说设计模式分为三大类：

创建型模式，共五种：工厂方法模式（Factory Method）、抽象工厂模式（Abstract Factory）、单例模式（Singleton）、建造者模式（Builder）、原型模式（Prototype）。

结构型模式，共七种：适配器模式（Adapter）、装饰器模式（Decorator）、代理模式（Proxy）、外观模式（Facade）、桥接模式（Bridge）、组合模式（Composite）、享元模式（Flyweight）。

行为型模式，共十一种：策略模式（strategy）、模板方法模式（Template Method）、观察者模式（Observer）、迭代子模式（Iterator）、 责任链模式（Chain of Responsibility）、命令模式（Command）、备忘录模式（Memento）、状态模式（State）、访问者模式（Visitor）、中介者模式（Mediator）、解释器模式（Interpreter）。

其实还有两类： 并发型模式和线程池模式。

单例对象（Singleton）是一种常用的设计模式。在Java应用中，单例对象能保证在一个JVM中，该对象只有一个实例存在。

要保证对象唯一

1，为了避免其他程序过多建立该类对象。先禁止其他程序建立该类对象

2，还为了让其他程序可以访问到该类对象，只好在本类中，自定义一个对象。

3，为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式。

这三部怎么用代码体现呢？

1，将构造函数私有化。

2，在类中创建一个本类对象。

3，提供一个方法可以获取到该对象。

记录原则：定义单例，建议使用饿汉式。

先初始化对象。称为：**饿汉式**。Single类一进内存，就已经创建好了对象。

class Single\{

// 在类中创建一个本类对象

private static Single s = new Single();

// 将构造函数私有化

private Single()\{ \}

// 提供一个方法可以获取到该对象

public static Single getInstance()\{

return s;

对象是方法被调用时，才初始化，也叫做对象的延时加载。成为：**懒汉式**。

Single类进内存，对象还没有存在，只有调用了getInstance方法时，才建立对象。

class Single\{

private static Single s = null;

private Single()\{ \}

public static Single getInstance()\{

if(s==null)\{

// 加了一个锁

synchronized(Single.class)\{

if(s==null)

s = new Single();

return s;

**8:继承（extends）**

继承的特点

1，提高了代码的复用性。

2，让类与类之间产生了关系。有了这个关系，才有了多态的特性。

java支持多层继承。也就是一个继承体系

子父类出现后， **类成员**的特点：

**　　　　1,变量**

如果子类中出现非私有的同名成员变量时，子类要访问本类中的变量，用this。子类要访问父类中的同名变量，用super。

**　　　　　　super关键字**

this代表的是本类对象的引用。

super代表的是父类对象的引用。

super()和this()是否可以同时出现的构造函数中。

两个语句只能有一个定义在第一行，所以只能出现其中一个。

super()或者this():为什么一定要定义在第一行？

因为super()或者this()都是调用构造函数，构造函数用于初始化，所以初始化的动作要先完成。

**　　　　2,子父类中的函数**

当子类出现和父类一模一样的函数时，当子类对象调用该函数，会运行子类函数的内容。如同父类的函数被覆盖一样。这种情况是函数的另一个特性：重写(覆盖)。当子类继承父类，沿袭了父类的功能，到子类中，但是子类虽具备该功能，但是功能的内容却和父类不一致，这时，没有必要定义新功能，而是使用覆盖特殊，保留父类的功能定义，并重写功能内容。

覆盖：

1，子类覆盖父类，必须保证子类权限大于等于父类权限，才可以覆盖，否则编译失败。

2，静态只能覆盖静态。

**　　　　3，子父类中的构造函数**

在对子类对象进行初始化时，父类的构造函数也会运行， 那是因为子类的构造函数默认第一行有一条隐式的语句 super();。

**super():会访问父类中空参数的构造函数。**而且子类中所有的构造函数默认第一行都是super();

**为什么子类一定要访问父类中的构造函数**

因为父类中的数据子类可以直接获取。所以子类对象在建立时，需要先查看父类是如何对这些数据进行初始化的。所以子类在对象初始化时，要先访问一下父类中的构造函数。如果要访问父类中指定的构造函数，可以通过手动定义super语句的方式来指定。super语句一定定义在子类构造函数的第一行。

**　子类的实例化过程**

子类的所有的构造函数，默认都会访问父类中空参数的构造函数。当父类中没有空参数的构造函数时，子类必须手动通过super语句形式来指定要访问父类中的构造函数。当然：子类的构造函数第一行也可以手动指定this语句来访问本类中的构造函数。子类中至少会有一个构造函数会访问父类中的构造函数。

**　　final关键**字最终作为一个修饰符

1，可以修饰类，函数，变量。

2，被final修饰的类不可以被继承。为了避免被继承，被子类复写功能。

3，被final修饰的方法不可以被复写。

4，被final修饰的变量是一个常量只能赋值一次，既可以修饰成员变量，有可以修饰局部变量。当在描述事物时，一些数据的出现值是固定的，那么这时为了增强阅读性，都给这些值起个名字。方便于阅读。而这个值不需要改变，所以加上final修饰。作为常量：常量的书写规范所有字母都大写，如果由多个单词组成。单词间通过\_连接。

5，内部类定义在类中的局部位置上是，只能访问该局部被final修饰的局部变量。

**9:抽象类 (abstract)**

抽象类的特点：

1，抽象方法一定在抽象类中。

2，抽象方法和抽象类都必须被abstract关键字修饰。

3，抽象类不可以用new创建对象。因为调用抽象方法没意义。

4，抽象类中的抽象方法要被使用，必须由子类复写起所有的抽象方法后，建立子类对象调用。如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象类。

抽象类比一般类多个了抽象函数。就是在类中可以定义抽象方法。抽象类不可以实例化。

特殊：抽象类中可以不定义抽象方法，这样做仅仅是不让该类建立对象。

**　　与abstract不能共存的关键字**

final：被final修饰的类不能有子类。而被abstract修饰的类一定是一个父类。

private: 抽象类中的私有的抽象方法，不被子类所知，就无法被复写。而抽象方法出现的就是需要被复写。

static：如果static可以修饰抽象方法，那么连对象都省了，直接类名调用就可以了。可是抽象方法运行没意义。

模版方法设计模式

在定义功能时，功能的一部分是确定的，但是有一部分是不确定，而确定的部分在使用不确定的部分，那么这时就将不确定的部分暴露出去。由该类的子类去完成。

**10:接口 (interface )**

接口：初期理解，可以认为是一个特殊的抽象类,当抽象类中的方法都是抽象的，那么该类可以通过接口的形式来表示。

class用于定义类

interface 用于定义接口。

接口定义时，格式特点：

1，接口中常见定义：常量，抽象方法。

2，接口中的成员都有固定修饰符。

常量：public static final

方法：public abstract

接口中的成员都是public的。

**接口的特点：**

接口是对外暴露的规则

接口是程序的功能扩展

接口可以用来多实现

类与接口之间是实现关系，而且类可以继承一个类的同时实现多个接口

接口与接口之间可以有继承关系

接口：是不可以创建对象的，因为有抽象方法。需要被子类实现，子类对接口中的抽象方法全都覆盖后，子类才可以实例化。否则子类是一个抽象类。

接口可以被类多实现，也是对多继承不支持的转换形式。java支持多实现。

**11:多态**

定义：某一类事物的多种存在形态。

1，多态的体现

父类的引用指向了自己的子类对象，也可以接收自己的子类对象。

2，多态的前提

必须是类与类之间有关系。要么继承，要么实现。通常还有一个前提：存在覆盖。

3，多态的好处

多态的出现大大的提高程序的扩展性。

4，多态的弊端：

提高了扩展性，但是只能使用父类的引用访问父类中的成员。

5，多态的应用

equals()

6，多态的出现代码中的特点(多态使用的注意事项)

我们能转换的是父类应用指向了自己的子类对象时，该应用可以被提升，也可以被强制转换。

多态自始至终都是子类对象在做着变化。

** ** **instanceof** : 用于判断对象的类型。 对象 intanceof 类型(类类型 接口类型)

在多态中成员函数的特点：

在编译时期：参阅引用型变量所属的类中是否有调用的方法。如果有，编译通过，如果没有编译失败。

在运行时期：参阅对象所属的类中是否有调用的方法。

在多态中，成员变量的特点：无论编译和运行，都参考左边(引用型变量所属的类)。

在多态中，静态成员函数的特点：无论编译和运行，都参考做左边。

**12.Object类**

Object:是所有对象的直接或者间接父类。该类中定义的肯定是所有对象都具备的功能。Object类中已经提供了对对象是否相同的比较方法。如果自定义类中也有比较相同的功能，没有必要重新定义。只要沿袭父类中的功能，建立自己特有比较内容即可。这就是覆盖。

equals方法 指示其他某个对象是否与此对象“相等”

toString方法 返回该对象的字符串表示

**13.内部类**

将一个类定义在另一个类的里面，对里面那个类就称为内部类（内置类，嵌套类）

内部类的访问规则：

1，内部类可以直接访问外部类中的成员，包括私有。之所以可以直接访问外部类中的成员，是因为内部类中持有了一个外部类的引用，

格式 外部类名.this

2，外部类要访问内部类，必须建立内部类对象。

访问格式：

①,当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中,直接建立内部类对象。

格式

外部类名.内部类名  变量名 = 外部类对象.内部类对象;

Outer.Inner in = new Outer().new Inner();

②,当内部类在成员位置上，就可以被成员修饰符所修饰。

比如，private：将内部类在外部类中进行封装。

内部类具备static的特性。

当内部类被static修饰后，只能直接访问外部类中的static成员。出现了访问局限。

在外部其他类中，如何直接访问static内部类的非静态成员呢？new Outer.Inner().function();

在外部其他类中，如何直接访问static内部类的静态成员呢？Outer.Inner.function();

注意：当内部类中定义了静态成员，该内部类必须是static的。 当外部类中的静态方法访问内部类时，内部类也必须是static的。

内部类定义在局部时，

1，不可以被成员修饰符修饰

2，可以直接访问外部类中的成员，因为还持有外部类中的引用。

但是不可以访问它所在的局部中的变量。只能访问被final修饰的局部变量。

匿名内部类:

1，匿名内部类其实就是内部类的简写格式。

2，定义匿名内部类的前提：内部类必须是继承一个类或者实现接口。

3，匿名内部类的 格式：   **new** 外部类名或者接口名**()\{** 覆盖类或者接口中的代码，(也可以自定义内容。)**\}**

4，其实匿名内部类就是一个匿名子类对象。而且这个对象有点胖。可以理解为带内容的对象。

5，匿名内部类中定义的方法最好不要超过3个。

例

interface Inter\{

void method();

class Test \{

**　　　　//补足代码。通过内部类。**

static class Inner implements Inter\{

public void method()\{

System.out.println("method run");

static Inter function()\{

return new Inner();

**　　　　//补足代码。通过匿名内部类。**

static Inter function()\{

return new Inter()\{

public void method()\{

System.out.println("method run");

\};

class InnerClassTest \{

public static void main(String\[\] args) \{

Test.function().method();         //  =       Inter in = Test.function();

//     in.method();

Test.function():  // Test类中有一个静态的方法function。

method():     //  function这个方法运算后的结果是一个对象。而且是一个Intger类型的对象。

//因为只有是Inter类型的对象，才可以调用method方法。

例：

匿名内部类:   
　　class InnerClass\{

public static void main(String\[\] args) \{

show **(**new Inter()\{

public void method()\{

System.out.println("method show run");

\} **)**;  **  \}** 是子类代码结束 **)**是参数结束 **;**是这条语句结束

public static void show(Inter in)\{

in.method();

例：

class InnerTest\{

public static void main(String\[\] args)\{

new Object() \{       // new Object();创建了一个上帝 //new Object()\{ \}Object的子类对象

public void function()\{

\} **.**function();

**14.异常**

异常：是什么？是对问题的描述。将问题进行对象的封装。

异常的体系

Throwable

|——Error

|——Exception

|——RuntimeException

①Error

通常出现重大问题如：运行的类不存在或者内存溢出等

不缩写针对代码对其处理

②Exception

在运行时运行出现的一起情况，可以通过try catch finally

异常的处理

java 提供了特有的语句进行处理。

try \{ 需要被检测的代码；\}

catch ( 异常类 变量 ) \{ 处理异常的代码；(处理方式) \}

finally \{ 一定会执行的语句； \}

有三个结合格式：

1.try\{ \}

catch ()\{ \}

2.try\{  \}

finally\{ \}

3.try\{  \}

catch ()\{ \}

finally\{ \}

注意：

1，finally中定义的通常是 关闭资源代码。因为资源必须释放。

2，finally只有一种情况不会执行。当执行到System.exit(0);fianlly不会执行。

**　　throws关键** **字**，声明该功能有可能会出现问题

throw和throws的用法：

throw定义在函数内，用于抛出异常对象。

throws定义在函数上，用于抛出异常类，可以抛出多个用逗号隔开。

**　　** 当函数内容有throw抛出异常对象，并未进行try处理。必须要在函数上声明，否则编译失败。

RuntimeException除外。也就说，函数内如果抛出的RuntimeExcpetion异常，函数上可以不用声明。

如果函数声明了异常，调用者需要进行处理。处理方法可以throws可以try。

异常有两种：

编译时被检测异常

该异常在编译时，如果没有处理(没有抛也没有try)，编译失败。

该异常被标识，代表这可以被处理。

运行时异常(编译时不检测)

在编译时，不需要处理，编译器不检查。

该异常的发生，建议不处理，让程序停止。需要对代码进行修正。

对捕获到的异常对象进行常见方法操作。

String   getMessage()： 获取异常信息。

toString()     // 异常名称 ： 异常信息。

printStackTrace()     //异常名称，异常信息，异常出现的位置。

//其实jvm默认的异常处理机制，就是在调用printStackTrace方法。

//打印异常的堆栈的跟踪信息。

对多异常的处理。

1，声明异常时，建议声明更为具体的异常。这样处理的可以更具体。

2，对方声明几个异常，就对应有几个catch块。不要定义多余的catch块。如果多个catch块中的异常出现继承关系，父类异常catch块放在最下面。在进行catch处理时，catch中一定要定义具体处理方式。也不要简单的就书写一条输出语句。

自定义异常：

定义类继承Exception或者RuntimeException

1,为了让该自定义类具备可抛性。

2，让该类具备操作异常的共性方法。

当要定义自定义异常的信息时，可以使用父类已经定义好的功能。

异常异常信息传递给父类的构造函数。

class MyException extends Exception\{

MyException(String message)\{

super(message);

自定义异常：按照java的面向对象思想，将程序中出现的特有问题进行封装。

异常的好处：

1，将问题进行封装。

2，将正常流程代码和问题处理代码相分离，方便于阅读。

异常的处理原则：

1，处理方式有两种：try 或者 throws。

2，调用到抛出异常的功能时，抛出几个，就处理几个。一个try对应多个catch。

3，多个catch，父类的catch放到最下面。

4，catch内，需要定义针对性的处理方式。不要简单的定义printStackTrace，输出语句。也不要不写。当捕获到的异常，本功能处理不了时，可以继续在catch中抛出。

try\{

throw new AException();

catch (AException e)\{

throw e;

如果该异常处理不了，但并不属于该功能出现的异常。可以将异常转换后，在抛出和该功能相关的异常。或者异常可以处理，当需要将异常产生的和本功能相关的问题提供出去，让调用者知道，并处理。也可以将捕获异常处理后，转换新的异常。

try\{

throw new AException();

catch (AException e)\{

// 对AException处理。

throw new BException();

异常的注意事项：

在子父类覆盖时：

1，子类抛出的异常必须是父类的异常的子类或者子集。

2，如果父类或者接口没有异常抛出时，子类覆盖出现异常，只能try不能抛。

**15.包 （package）**

①对类文件进行分类管理

②给类提供多层命名空间

③写在程序文件的第一行

④类名的全称是  包名.类名

⑤包也是一种封装形式

为了简化类名的书写，使用一个关键字， **import.**

建议，不要写通配符 \* ，需要用到包中的哪个类，就导入哪个类。

总结：

包与包之间进行访问，被访问的包中的类以及类中的成员，需要public修饰。

不同包中的子类还可以直接访问父类中被protected权限修饰的成员。

包与包之间可以使用的权限只有两种， **public  protected**（保护）。

（ 权限）       public    protected       default     private

同一个类中      ok             ok                ok          ok

同一个包中      ok             ok                ok

子类               ok             ok

不同包中         ok

常见包：

java.lang  **:** java的核心包 jdk1.2版本以后，该包中的类自动导入。

java.awt **:** 用于制作图形界面。

java.io **: ** 用于操作设备上的数据。

java.util ** :** 这里定义是java的工具类。集合，日期。

java.net **:**用于网络通讯的。

jar 包

——————————  ASP.Net+Android+IOS开发、.Net培训、期待与您交流！——————————

* 详细请查看：http://edu.csdn.net *

转载于:https://www.cnblogs.com/In-order-to-tomorrow/p/3528517.html

黑马程序员_java基础笔记(03)...面向对象

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关黑马python基础班---day03

相关黑马程序员——Java基础加强---反射

相关黑马程序员---JavaScript基础---02

相关黑马程序员_java基础笔记(11)...反射

相关黑马程序员_java基础笔记(12)...内省（IntroSpector）

相关 6-1 jmu-Java-03面向对象基础-Object

相关黑马程序员-面向对象-08天-2

相关黑马程序员_java基础笔记(02)...java语言基础组成

相关黑马程序员_java基础笔记(03)...面向对象

相关黑马程序员_java基础笔记(06)...集合