Java-面向对象01

小悟空GK

已于 2023-07-30 23:40:42 修改

阅读量56

点赞数

分类专栏： Java 文章标签：开发语言 java

于 2023-07-30 11:44:04 首次发布

本文链接：https://blog.csdn.net/qq_48114126/article/details/132005245

版权

Java 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

1. 面向对象概述

1.1 面向过程和面向对象

面向过程：Procedure Oriented Programming

面向过程，强调的是功能行为，以函数为最小单位

面向对象：Object Oriented Programming

面向对象，将功能封装进对象，强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。面向对象更加强调运用人类在日常的思维逻辑中采用的思想方法与原则，如抽象、分类、继承、聚合、多态等。

1.2 面向对象的三大特征

封装 (Encapsulation)
继承 (Inheritance)
多态 (Polymorphism)

！！！程序设计的原则

单一职责原则（Single Responsibility Principle）

每一个类应该专注于做一件事情。
里氏替换原则（Liskov Substitution Principle）

超类存在的地方，子类是可以替换的。
依赖倒置原则（Dependence Inversion Principle）

实现尽量依赖抽象，不依赖具体实现。
接口隔离原则（Interface Segregation Principle）
应当为客户端提供尽可能小的单独的接口，而不是提供大的总的接口。
迪米特法则（Law Of Demeter）
又叫最少知识原则，一个软件实体应当尽可能少的与其他实体发生相互作用。
开闭原则（Open Close Principle）

面向扩展开放，面向修改关闭。
组合/聚合复用原则（Composite/Aggregate Reuse Principle CARP）
尽量使用合成/聚合达到复用，尽量少用继承。原则：一个类中有另一个类的对象。
类和类的关系https://zhuanlan.zhihu.com/p/359672087

！！！组合>聚合>关联>依赖

继承

继承是面向对象最显著的一个特性。继承是从已有的类（父类、父接口）中派生出新的类（子类、子接口），新的类能吸收已有类的数据属性和行为，并能扩展新的能力。在Java中此类关系通过关键字extends明确标识。

例如你可以先定义一个类叫动物(Animal), 然后再定义一个子类鸟(Bird), 子类鸟具有父类Animal的一切属性和行为，同时还可以扩展自己独特的属性和行为。

一般用一个带空心箭头的实线表示继承关系，用UML图表示如下：

实现

实现是类和接口之间最常见的关系。指的是一个类实现接口的功能（一个类可以实现多个接口).在Java中此类关系通过关键字implements明确标识。

例如定义一个接口Fly(表示会飞），然后定义一个类Bird实现该接口。

一般用一个带空心箭头的虚线表示实现关系，用UML表示如下：

依赖

依赖关系是指一个类对另外一个类的依赖。这种关系是一种非常弱、临时性的关系。依赖关系在Java语言中体现为局域变量、方法的形参，或者对静态方法的调用。

比如说Employee类中有一个方法叫做TakeMoney(Bank bank)这个方法，在这个方法的参数中用到了Bank这个类。那么这个时候可以说Employee类依赖了Bank这个类，如果Bank这个类发生了变化那么会对Employee这个类造成影响。

一般用一条指向被依赖事物的虚线表示依赖关系，用UML图表示依赖关系如下：

关联

关联关系是类与类之间的联接，它使一个类知道另一个类的属性和方法。关联可以是双向的，也可以是单向的，它是依赖关系更强的一种关系。

在java语言中，关联关系一般表现为被关联类B以类属性的形式出现在关联类A中，也可能是关联类A引用了一个类型为被关联类B的全局变量；

一般用实线连接有关联的两个类，用UML图表示如下：

聚合

聚合是一种特殊的关联关系，它是较强的一种关联关系，强调的是整体与部分之间的关系，从语法上是没办法区分的，只能从语义上区分。

例如雁群和大雁的关系、学校和学生之间的关系。

聚合的整体和部分之间在生命周期上没有什么必然的联系，部分对象可以在整体对象创建之前创建，也可以在整体对象销毁之后销毁。

一般用带一个空心菱形（整体的一端）的实线表示，用UML图表示如下：

组合

组合也是关联关系的一种特例，这种关系比聚合关系更强。它强调了整体与部分的生命周期是一致的，而聚合的整体和部分之间在生命周期上没有什么必然的联系。

在组合关系中，整体与部分是不可分的，整体的生命周期结束也就意味着部分的生命周期结束。

例如大雁和大雁的翅膀是组合关系。一般用带实心菱形(整体的一端)的实线来表示。UML图如下：

总结：

对于继承、实现这两种关系比较简单，他们体现的是一种类与类、或者类与接口间的纵向关系；其他的四者关系则体现的是类与类、或者类与接口间的引用、横向关系。总的来说，这几种关系所表现的强弱程度依次为：组合>聚合>关联>依赖

2. 类和对象

2.1 概述

类(Class)和对象(Object)是面向对象的核心概念。

类是对一类事物的描述，是抽象的、概念上的定义
对象是实际存在的该类事物的每个个体，因而也称为实例(instance)。
可以理解为：类 = 抽象概念的人；对象 = 实实在在的某个人
面向对象程序设计的重点是类的设计
类的设计，其实就是类的成员的设计

2.2 类的成员

现实生物世界中的细胞又是由什么构成的呢？细胞核、细胞质、… 那么，Java中用类class来描述事物也是如此。常见的类的成员有：

属性：对应类中的成员变量
行为：对应类中的成员方法

Field = 属性 = 成员变量，

Method = (成员)方法=函数

2.3 内存解析

在Java中，“堆”（Heap）是一种用于动态分配内存的数据结构，用于存储对象实例和数组。Java中的所有对象都存储在堆中，包括通过关键字"new"创建的对象。

以下是关于Java堆的一些重要信息：

堆的特点：Java堆是一块运行时数据区域，它具有自动分配和释放内存的特性。它不同于栈，栈是用于存储局部变量和方法调用的执行上下文。
对象实例分配：当使用关键字"new"创建对象时，Java运行时系统会在堆上分配一块内存来存储该对象的实例。堆上的内存分配可以由Java虚拟机（JVM）自动处理。
垃圾回收：Java堆通过垃圾回收器（Garbage Collector）来自动管理内存。垃圾回收器会定期检查堆中的对象，释放不再使用的内存，以便其他对象可以使用。
堆的内存分配：Java堆是按照对象大小动态分配内存的。对象的大小在运行时可以确定，因此可以根据需要从堆中分配一块足够大的内存。

请注意，Java堆的管理是由Java虚拟机负责的，开发者无需直接操作堆内存。然而，了解堆的概念和特性对于理解Java内存管理机制和编写高效的Java程序是很重要的。

在Java中，“栈”（Stack）是一种用于存储方法调用和局部变量的执行上下文的数据结构。栈的管理由Java虚拟机（JVM）负责。

以下是关于Java栈的一些重要信息：

栈的特点：Java栈是一块运行时数据区域，它以"先进后出"（LIFO）的方式存储方法的调用和返回记录。栈的大小在程序运行前就固定了。
方法调用：每当在Java程序中调用一个方法时，栈会分配一块称为"栈帧"（Stack Frame）的内存空间。每个栈帧都包含方法的参数、局部变量和方法返回值等信息。
局部变量存储：Java方法中定义的局部变量（包括基本类型和对象引用）都存储在栈中。当方法执行结束后，栈帧会被弹出，并释放相关的内存空间。
方法调用的嵌套：当一个方法调用另一个方法时，会在栈上创建一个新的栈帧，将控制权传递给被调用的方法。被调用的方法执行完毕后，控制权会返回到调用方法的栈帧上。
栈溢出：当栈的空间不足以容纳新的栈帧时，会发生栈溢出错误（StackOverflowError）。这通常是由于方法调用的嵌套层次太深或者递归调用没有正确终止导致的。

需要注意的是，栈和堆是Java程序中两种不同的数据区域，用于不同的目的。栈用于存储方法调用和局部变量，而堆用于存储对象实例和数组。理解栈和堆的区别和作用对于编写和调试Java程序是非常重要的。

方法区

在Java中，“方法区”（Method Area，有时也称为永久代，Permanent Generation）是一块用于存储类信息、常量、静态变量和编译器优化后的代码等数据的内存区域。方法区的管理由Java虚拟机（JVM）负责。

以下是关于Java方法区的一些重要信息：

存储类信息：方法区用于存储加载的类的信息，包括类的结构、字段、方法、构造函数、接口等。这些信息在程序运行期间是固定的。
常量池：方法区还包含一个常量池（Constant Pool），用于存储各种常量，如字符串字面值、类名、方法名等。常量池是类文件中的一部分，编译器会将常量存放在方法区的常量池中。
静态变量：方法区还用于存储类的静态变量的数据。静态变量在程序运行期间会一直存在，直到程序结束或该变量被显式销毁。
编译器优化后的代码：方法区还存储了编译器优化后的代码，包括方法的字节码等。这些优化后的代码可以提高程序的执行效率。

需要注意的是，Java 8以及之后的版本已经移除了永久代，并将方法区的一部分功能移到了元数据区（Metaspace）中。元数据区是方法区的替代品，用于存储类的元数据信息。元数据区的大小可根据需要动态调整，而永久代的大小是固定的。

了解方法区的作用和特点非常重要，特别是在处理大量类和静态变量时。同时，随着Java版本的不断更新，对于内存区域的管理也有所变化，需要根据具体的Java版本来理解和使用不同内存区域的概念和机制。

2.4 属性 Field

2.4.1 变量的分类

在方法体外，类体内声明的变量称为成员变量
在方法体内声明的变量称为局部变量

2.4.2 成员变量默认初始值

public class Person {
    private int i;
    short s;
    private char c;
    String str;
    int[] arr;
    @Override
    public String toString() {
    	return ""+ i + s + (int)c + str + arr;
    }
    public static void main(String[] args) {
        System.out.println(new Person());
    }
}
//结果 000nullnull

2.5 方法 Method

方法是类或对象行为特征的抽象，用来完成某个功能操作。在某些语言中也称为函数或过程。
将功能封装为方法的目的是，可以实现代码重用，简化代码
Java里的方法不能独立存在，所有的方法必须定义在类里。

格式：

修饰符 返回值类型 方法名（参数类型 形参1, 参数类型 形参2, ….）｛
方法体程序代码
return 返回值;
｝

2.5.1 方法的重载

在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。

重载的特点：与返回值类型无关，只看参数列表，且参数列表必须不同。(参数个数或参数类型)。调用时，根据方法参数列表的不同来区别。

//返回两个整数的和
int add(int x,int y){return x+y;}
//返回三个整数的和
int add(int x,int y,int z){return x+y+z;}
//返回两个小数的和
double add(double x,double y){return x+y;}

public class PrintStream {
    public static void print(int i) {……}
    public static void print(float f) {……}
    public static void print(String s) {……}
    public static void main(String[] args) {
        print(3);
        print(1.2f);
        print("hello!");
	}
}

使用案例：

编写程序，定义三个重载方法并调用。方法名为mOL。

三个方法分别接收一个int参数、两个int参数、一个字符串参数。分别执行平方运算并输出结果，

相乘并输出结果，输出字符串信息。

在主类的main ()方法中分别用参数区别调用三个方法。

定义三个重载方法max()，第一个方法求两个int值中的最大值，第二个方法求两个double值中的最大

值，第三个方法求三个double值中的最大值，并分别调用三个方法。

public class OverloadExer {
//1. 如下的三个方法构成重载
    public void mOL(int i){
    	System.out.println(i * i);
    }
    public void mOL(int i,int j){
    	System.out.println(i * j);
    }
    public void mOL(String s){
    	System.out.println(s);
    }
    //2.如下的三个方法构成重载
    public int max(int i,int j){
    	return (i > j)? i : j;
    }
    public double max(double d1,double d2){
    	return (d1 > d2)? d1 : d2;
    }
    public double max(double d1,double d2,double d3){
        double max = (d1 > d2)? d1 : d2;
        return (max > d3)? max : d3;
	}
}

2.5.2 可变参数

//JDK 5.0以前：采用数组形参来定义方法，传入多个同一类型变量
public static void test(int a ,String[] books);
//JDK5.0：采用可变个数形参来定义方法，传入多个同一类型变量
public static void test(int a ,String… books);

\1. 声明格式：方法名(参数的类型名 …参数名)

\2. 可变参数：方法参数部分指定类型的参数个数是可变多个：0个，1个或多个

\3. 可变个数形参的方法与同名的方法之间，彼此构成重载

\4. 可变参数方法的使用与方法参数部分使用数组是一致的

\5. 方法的参数部分有可变形参，需要放在形参声明的最后

\6. 在一个方法的形参位置，最多只能声明一个可变个数形参

public class Test2 {
    public void show(String[] arr) {
        for (int i = 0; i < arr.length; i++) {
        	System.out.println(arr[i]);
        }
    }
    
    public void display(String... arr) {
        for (int i = 0; i < arr.length; i++) {
        	System.out.println(arr[i]);
        }
    }
    
    public void display(String name, int... arr) {
        System.out.println("name=" + name);
        for (int i = 0; i < arr.length; i++) {
        	System.out.println(arr[i]);
        }
    }
    
    public static void main(String[] args) {
    	Test2 t2 = new Test2();
    	String[] strs = new String[] {"a", "b", "c"};
    	t2.show(strs);
        
   		System.out.println("--------------");
        
    	String[] strs2 = new String[] {"aa", "bb", "cc"};
    	t2.display(strs2);
        
    	System.out.println("--------------");
        
    	//可变参数用法
    	t2.display();
    	// t2.show(); //报错
        
    	System.out.println("--------------");
        
    	t2.display("mickey", "a", "b");
    	t2.display("mickey", 1, 2, 3);
    }
}

2.5.3 参数传递

方法，必须由其所在类或对象调用才有意义。若方法含有参数：

形参：方法声明时的参数
**实参：**方法调用时实际传给形参的参数值

Java里方法的参数传递方式只有一种：值传递。即将实际参数值的副本（复制品）传入方法内，而参数本身不受影响。

形参是基本数据类型：将实参基本数据类型变量的“数据值”传递给形参
形参是引用数据类型：将实参引用数据类型变量的“地址值”传递给形参
基本数据类型参数传递

public static void main(String[] args) {
    int x = 5;
    System.out.println("修改之前x = " + x);
    // x是实参
    change(x);
    System.out.println("修改之后x = " + x);
}
public static void change (int x){
    System.out.println("change:修改之前x = " + x);
    x = 3;
    System.out.println("change:修改之后x = " + x);
}

在这里插入图片描述

引用类型参数传递

public static void main(String[] args) {
    Person obj = new Person();
    obj.age = 5;
	System.out.println("修改之前age = " + obj.age);// 5
	// x是实参
	change(obj);
	System.out.println("修改之后age = " + obj.age);// 5
}
public static void change(Person obj) {
    obj = new Person();
    System.out.println("change:修改之前age = " + obj.age);
    obj.age = 3;
    System.out.println("change:修改之后age = " + obj.age);
}
//其中Person类定义为：
class Person{
int age;
}

!!! 案例1

public class ValueTransferTest1 {
    public static void main(String[] args) {
        int m = 10;
        int n = 20;
        System.out.println("m = " + m + ", n = " + n);
        
        ValueTransferTest1 test = new ValueTransferTest1();
        test.swap(m, n);
        
        System.out.println("m = " + m + ", n = " + n);
    }
    public void swap(int m,int n){
        int temp = m ;
        m = n;
        n = temp;
    }
}

在这里插入图片描述

!!!！案例2

public class ValueTransferTest2 {
    public static void main(String[] args) {
        Data data = new Data();
        data.m = 10;
        data.n = 20;
        System.out.println("m = " + data.m + ", n = " + data.n);
        ValueTransferTest2 test = new ValueTransferTest2();
        test.swap(data);
        System.out.println("m = " + data.m + ", n = " + data.n);
	}
    public void swap(Data data){
        int temp = data.m;
        data.m = data.n;
        data.n = temp;
    }
}
class Data{
    int m;
    int n;
}

在这里插入图片描述

2.5.4 递归方法

递归方法：一个方法调用它自身。

方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无须循环控制。
递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环。

public class RecursionTest {
    public static void main(String[] args) {
        
    	// 例1：计算1-100之间所有自然数的和
    	// 方式一：
    	int sum = 0;
    	for (int i = 1; i <= 100; i++) {
    		sum += i;
    	}
   		System.out.println(sum);
        
        // 方式二：
    	RecursionTest test = new RecursionTest();
    	int sum1 = test.getSum(100);
    	System.out.println(sum1);
        
    	System.out.println("*****************");
    	int value = test.f(10);
    	System.out.println(value);
    }
    
    // 例1：计算1-n之间所有自然数的和
    public int getSum(int n) {// 3
        
    	if (n == 1) {
    		return 1;
    	} else {
    		return n + getSum(n - 1);
    	}
    }
    
    // 例2：计算1-n之间所有自然数的乘积:n!
    public int getSum1(int n) {
    	if (n == 1) {
    		return 1;
    	} else {
   		return n * getSum1(n - 1);
    	}
    }
}

3. 面向对象基础

3.1 封装

我们程序设计追求“高内聚，低耦合”。
高内聚：类的内部数据操作细节自己完成，不允许外部干涉；
低耦合：仅对外暴露少量的方法用于使用。
隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提高系统的可扩展性、可维护性。通俗的说，把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装性的设计思想
eg:

class Animal {
    public int legs;
    public void eat(){
    	System.out.println("Eating");
    }
    public void move(){
    	System.out.println("Moving.");
    }
}
public class Zoo {
	public static void main(String args[]) {
    Animal xb = new Animal();
    xb.legs = 4; //问题：xb.legs = -1000，解决方式将legs属性封装起来，防止乱用
    System.out.println(xb.legs);
    xb.eat();
    xb.move();
    }
}

Java中通过将数据声明为私有的(private)，再提供公共的（public）方法:**getXxx()和setXxx()**实现

对该属性的操作，以实现下述目的：

隐藏一个类中不需要对外提供的实现细节；
使用者只能通过事先定制好的方法来访问数据，可以方便地加入控制逻辑，限制对属性的不合理操作；
便于修改，增强代码的可维护性；

class Animal {
    private int legs;// 将属性legs定义为private，只能被Animal类内部访问
    public void setLegs(int i) { // 在这里定义方法 eat() 和 move()
        if (i != 0 && i != 2 && i != 4) {
        System.out.println("Wrong number of legs!");
        return;
    	}
    	legs = i;
    }
    public int getLegs() {
    	return legs;
    }
}
public class Zoo {
    public static void main(String args[]) {
    	Animal xb = new Animal();
    	xb.setLegs(4); // xb.setLegs(-1000);
    //xb.legs = -1000; // 非法
    	System.out.println(xb.getLegs());
    }
}

3.2 构造函数

构造器的特征

它具有与类相同的名称

它不声明返回值类型。（与声明为void不同）

不能被static、final、synchronized、abstract、native修饰，不能有return语句返回值
构造器的作用：创建对象；给对象进行初始化

如：Order o = new Order(); Person p = new Person(“Peter”,15);

如同我们规定每个“人”一出生就必须先洗澡，我们就可以在“人”的构造器中加入完成“洗澡”的程序代码，于是每个“人”一出生就会自动完成“洗澡”，程序就不必再在每个人刚出生时一个一个地告诉他们要“洗澡”了。

案例1

public class Animal {
    private int legs;
    // 构造器
    public Animal() {
    	legs = 4;
    }
    public void setLegs(int i) {
    	legs = i;
    }
    public int getLegs() {
    	return legs;
    }
}

根据参数不同，构造器可以分为如下两类：
- 隐式无参构造器（系统默认提供）
- 显式定义一个或多个构造器（无参、有参）
Java语言中，每个类都至少有一个构造器
默认构造器的修饰符与所属类的修饰符一致
一旦显式定义了构造器，则系统不再提供默认构造器
一个类可以创建多个重载的构造器
父类的构造器不可被子类继承

案例2

创建程序,在其中定义两个类：Person和PersonTest类。定义如下：用setAge()设置人的合法年龄(0~130)，用getAge()返回人的年龄。
- 前面定义的Person类中添加构造器，利用构造器设置所有人的age属性初始值都为18。
- 修改上题中类和构造器，增加name属性,使得每次创建Person对象的同时初始化对象的age属性值和name属性值。

public class Person {
    private int age;
    private String name;
    
    public Person(){
    	age = 18;
   	}
    
    public Person(String n,int a){
        name = n;
        age = a;
    }
    public void setAge(int a){
        if(a < 0 || a > 130){
            // throw new RuntimeException("传入的数据非法！");
            System.out.println("传入的数据非法！");
            return;
    	}
    	age = a;
	}
    
	public int getAge(){
		return age;
	}
	public void setName(String n){
		name = n;
	}
	public String getName(){
		return name;
	}
}
public class PersonTest {
	public static void main(String[] args) {
		Person p1 = new Person();
		p1.setAge(12);
		System.out.println("年龄为：" + p1.getAge());
		Person p2 = new Person("Tom", 21);
		System.out.println("name = " + p2.getName() + ",age = " +
		p2.getAge());
	}
}

3.3 JavaBean类

所谓JavaBean，是指符合如下标准的Java类：

类是公共的
有一个无参的公共的构造器
有属性，且有对应的get、set方法

public class People {
    private String name;
    private int age;
    
    public People() {
    }
    public People(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    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;
    }
}

3.4 this关键词

在Java中，this关键字比较难理解，它的作用和其词义很接近。

它在方法内部使用，即这个方法所属对象的引用；

它在构造器内部使用，表示该构造器正在初始化的对象。

this 可以调用类的属性、方法和构造器

当在方法内需要用到调用该方法的对象时，就用this。
具体的：我们可以用this来区分属性和局部变量。比如：this.name = name;

案例1：

class Person{ // 定义Person类
    private String name ;
    private int age ;
    public Person(String name,int age){
    	this.name = name ;
    	this.age = age ;
    }
    public void getInfo(){
        System.out.println("姓名：" + name) ;
        this.speak();
    }
    public void speak(){
    	System.out.println(“年龄：” + this.age);
    }
}

案例2

class Person{ // 定义Person类
    String name;
    Person(String name){
    	this.name = name;
    }
    public void getInfo(){
    	System.out.println("Person类 --> " + this.name) ;
    }
    public boolean compare(Person p){
   		return this.name==p.name;
    }
}
public class PersonTest{
    public static void main(String args[]){
        Person per1 = new Person("张三") ;
        Person per2 = new Person("李四") ;
        per1.getInfo() ; // 当前调用getInfo()方法的对象是per1
        per2.getInfo() ; // 当前调用getInfo()方法的对象是per2
        boolean b = per1.compare(per2);
	}
}

3.5 package和import

package语句作为Java源文件的第一条语句，指明该文件中定义的类所在的包。(若缺省该语句，则指定为无名包)，包通常用小写单词标识。通常使用所在公司域名的倒置： com.lxs.xxx

包帮助管理大型软件系统：将功能相近的类划分到同一个包中。比如：MVC的设计模式：将整个程序分为三个层次：视图模型层，控制器层，与数据模型层。这种将程序输入输出、数据处理，以及数据的展示分离开来的设计模式使程序结构变的灵活而且清晰，同时也描述了程序各个对象间的通信方式，降低了程序的耦合性。
包可以包含类和子包，划分项目层次，便于管理
解决类命名冲突的问题
控制访问权限

JAVA常用的包

java.lang----包含一些Java语言的核心类，如String、 Math、 Integer、 System和Thread，提供常用功能
java.net----包含执行与网络相关的操作的类和接口。
java.io ----包含能提供多种输入/输出功能的类。
java.util----包含一些实用工具类，如定义系统特性、接口的集合框架类、使用与日期日历相关的函数。
java.text----包含了一些java格式化相关的类
java.sql----包含了java进行JDBC数据库编程的相关类/接口
java.awt----包含了构成抽象窗口工具集（abstract window toolkits）的多个类，这些类被用来构建和管理应用程序的图形用户界面(GUI)。

小悟空GK

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
Java-面向对象01

类(Class)和对象(Object)是面向对象的核心概念。类是对一类事物的描述，是抽象的、概念上的定义对象是实际存在的该类事物的每个个体，因而也称为实例(instance)。类抽象概念的人；对象实实在在的某个人面向对象程序设计的重点是类的设计类的设计，其实就是类的成员的设计。
复制链接

扫一扫