面向对象修炼手册（一）（类与对象）（Java宝典）

十二月的猫

已于 2024-06-23 09:36:26 修改

阅读量875

点赞数 11

分类专栏：面向对象修炼手册文章标签： java 开发语言面向对象编程

于 2024-06-21 14:50:26 首次发布

本文链接：https://blog.csdn.net/m0_67656158/article/details/139841395

版权

面向对象修炼手册专栏收录该内容

4 篇文章 0 订阅

订阅专栏

🌈 个人主页：十二月的猫-CSDN博客
🔥 系列专栏： 🏀面向对象修炼手册

💪🏻 十二月的寒冬阻挡不了春天的脚步，十二点的黑夜遮蔽不住黎明的曙光

思想

代理和团体

1、解决问题就是找到解决问题的人（代理）

2、代理有责任完成任务

3、代理完成任务的细节是隐藏的

类

1 基本概念

属性：在类中表示这类对象或实体拥有的特性
方法：对象能够执行的操作
静态属性：多个对象共同拥有，共享的数据（可以认为是类拥有，对象之间共享的属性）
静态方法：静态方法是类拥有，可以通过对象使用，也可以通过类使用的一类方法（在后面设计模式中的单例模式中，就用静态方法实现全局访问以及延迟初始化）；静态方法只能调用静态变量；构造和析构函数不能是静态成员

1.1 变量

1.1.1 静态变量

静态变量在类中就是静态属性
静态变量在类中是所有对象共享使用的
静态变量的初始化具有延迟性（加载类时才初始化）

初始化：

在声明中初始化

static int i = 5;
static int j = 6;

在静态代码块中初始化

static int i;
static int j;
static{
    i = 5;
    j = 6;
}

在静态方法中初始化

  public static void initialize() {
        staticInt = 42;
        staticDouble = 3.14;
        staticBoolean = true;
        staticString = "Hello, World!";
    }

静态变量只能初始化一次
静态变量的初始化只能在类中进行（否则就直接初始化为默认值）

1、静态变量的初始化时机与类的初始化时机紧密相关（final类型的静态变量除外，它编译时初始化）。

2、在类的初始化阶段，java虚拟机执行类的初始化语句，为静态变量赋予初始值、执行静态代码块，所以静态变量的初始化时机即为类的初始化时机。

类初始化顺序：父类静态变量 --> 子类静态变量 --> 父类实例变量 --> 子类实例变量 --> 父类构造函数 --> 子类构造函数

1.1.2 成员变量

静态变量属于类（对象的全体），成员变量则属于每一个对象，即每个对象有一个自己的成员变量

1.1.3 静态变量和普通变量的区别

普通变量分为：全局变量、局部变量

静态变量与全局变量：

静态变量只初始化一次，全局变量可以多次初始化
静态变量作用域在该源文件，全局变量在该源程序

静态变量与局部变量：

静态变量只初始化一次，普通变量可以多次初始化
静态变量作用域在该源文件，普通变量在该代码块

1.2 方法

1.2.1 静态成员方法

不能访问非静态属性，只能访问静态属性
类方法可以直接调用，对象也可以调用
没有this操作，因为不存在示例
构造和析构函数不能是静态成员
类拥有，只有一份

1.2.2 普通成员方法

可以访问所有的属性（静态和普通）
在每个对象中都有一份拷贝，但是不属于类
只有对象可以调用，类不可以调用

静态方法只能调用静态方法和静态变量

普通方法能调用普通方法、普通变量、静态方法、静态变量

1.2.3 静态方法和普通方法的区别

static方法在内存中只有一份，而普通方法在每个被调用中都会维持一份拷贝

1.调用对象、引用变量不同

对于静态方法：是使用static关键字修饰的方法，又叫类方法。属于类的，不属于对象，在实例化对象之前就可以通过类名.方法名调用静态方法。（静态属性，静态方法都是属于类的，可以直接通过类名调用）。
A.在静态方法中，可以调用静态方法
B.在静态方法中，不能调用非静态方法
C.在静态方法中，可以引用类变量（即，static修饰的变量）
D.在静态方法中，不能引用成员变量（即，没有static修饰的变量）
E.在静态方法中，不能使用super和this关键字

对于非静态方法：是不含有static关键字修饰的普通方法，又称为实例方法，成员方法。属于对象的，不属于类的。（成员属性，成员方法是属于对象的，必须通过new关键字创建对象后，再通过对象调用）。
A.在普通方法中，可以调用普通方法。
B.在普通方法中，可以调用静态方法
C.在普通方法中，可以引用类变量和成员变量
D.在普通方法中，可以使用super和this关键字

2.调用方法不同

静态方法可以直接调用，类名调用和对象调用。（类名.方法名 / 对象名.方法名）
但是非静态方法只能通过对象调用。（对象名.方法名）

3.生命周期不同

静态方法的生命周期跟相应的类一样长，静态方法和静态变量会随着类的定义而被分配和装载入内存中。一直到线程结束，静态方法和静态属性才会被销毁。（也就是静态方法属于类）
非静态方法的生命周期和类的实例化对象一样长，只有当类实例化了一个对象，非静态方法才会被创建，而当这个对象被销毁时，非静态方法也马上被销毁。（也就是非静态方法属于对象）

1.3 常量

常量是指初始化赋值后不能再改变的变量

java用final定义常量

c++用const定义常量（与此同时，还有define和enum枚举）

// a变量
int a;
// b为常量,10为字面量
final int b = 10;
// str为变量,hello world为字面量
String str = "hello world";

1.4 修饰符

修饰符就是对变量的一些限制、说明符号，起到对变量的约束作用

1.4.1 Java访问修饰符

访问修饰符就是约束变量访问权限的一类符号，用来限制属性和方法所起作用的范围

private：私有的访问权限，仅仅能在类中访问，严格体现封装思想

default：默认访问权限，仅仅在同一个包中共享

protected：受保护访问权限，在同一个包中或不同包的子类中共享

public：公共访问权限，和所有人都可以共享

1、我的东西只能我自己用

2、我的东西可以和我的室友（住在一起）的人一起用

3、我的东西可以和我的室友，或者我的儿子一起用

4、我的东西大家都可以用

对象

1 基本概念

1.1 概念

可以认为是状态和行为的结合

状态：描述对象属性、特征
行为：描述对象能进行的操作

对象就是消息的接收器。从对象外部看，只能看到对象的行为

1.2 对象性质（五大性质）

封装性:信息隐藏
自治性:主动数据
通信性:并发
暂存性:作用域/期
永久性:文档串行化

1.3 对象创建

1.3.1 单一对象创建

java：

PlayingCard aCard = new PlayingCard(Diamond, 3);

c++：

PlayingCard * aCard = new PlayingCard(Diamond, 3);

1、java中指针并不暴露给程序员，避免了程序员主动对内存管理（java内部是有指针的）

2、java中的new意思是创建并返回一个类的对象，所以要用这个类作为容器放这个对象

3、c++中的new也是创建对象，但是它返回的是这个类的地址。因此前面要用指针

java的内存回收策略：

垃圾回收机制(Java,C#,Smalltalk)
时刻监控对象的操作，对象不再使用时，自动回收其所占内存。
通常在内存将要耗尽时工作。

1.3.2 对象数组创建

Linklist link[] = new Linklist[2];
for(int i=0;i<2;i++){
    link[i] = new Linklist();
}

1、new创建的是数组对象，此时数组对象里面是没有东西的

2、数组中的元素还要创建并放入

3、new一次只能创建一个对象

1.4 对象创建与声明

对象声明和创建分离：

Student lihua；
lihua= new Student();

变量声明和创建合一：

Student lihua=new Student();

1.5 对象和类的关系

对象是类的具体化，类是对象的抽象化
对象有两类：1、本身就是对象；2、由类实例化产生的对象
对象是在生活中所见、编程中所操作的事物对象
对象可以是类的实例，类是对象的模板

1.6 对象和实例的关系

实例一定是对象，对象不一定是实例
实例是由类实例化产生的对象
对象包括：实例对象（实例）、非实例对象
实例对象：类实例化产生的对象
非实例对象：本身就是对象，不是类产生的（例如：抽象累、接口等）

Type type = typeof(int);//Type是抽象类，不允许实例化，这里的type是Type类的对象，而非实例化对象（实例）

抽象类不能产生实例，因此这边的type只能是对象，但不是实例对象

class Person{}
class Program
{
    static void Main(string[] args)
    {
        Person person = new Person();//这里person既可以叫做Person类的对象，也可以叫实例化对象（实例）    
    }
}

person在这里既是对象又是实例（实例化对象）

2 内存分配

2.1 内存划分——单一对象

public class ClassDemo02 {
	public static void main(String args[]){
		Person per = new Person() ;
	}
}

内存块划分如下：

修改属性如下：

public class ClassDemo03 {
	public static void main(String args[]){
		Person per = new Person() ;
		per.name = "张三" ; 		// 为属性赋值
		per.age = 30 ;
		per.tell() ; 			// 调用类中的方法
	}
}

2.2 内存划分——多对象

运行代码如下：

public class ClassDemo04 {
	public static void main(String args[]) {
	 Person per1 = null;	// 声明per1对象
	 Person per2 = null;	// 声明per2对象
	 per1 = new Person();	// 实例化per1对象
	 per2 = new Person();	// 实例化per2对象
	 per1.name = "张三";	// 设置per1对象的name属性内容
	 per1.age = 30;	// 设置per1对象的age属性内容
	 per2.name = "李四";	// 设置per2对象的name属性内容
	 per2.age = 33;	// 设置per2对象的age属性内容
		System.out.print("per1对象中的内容 --> ") ;
		per1.tell();		// per1调用方法
		System.out.print("per2对象中的内容 --> ") ;
		per2.tell();		// per2调用方法
	}
}

内存划分如下：

2.2 内存划分——对象创建与引用传递

代码运行如下：

public class ClassDemo05 {
	public static void main(String args[]) {
	  Person per1 = null;	// 声明per1对象
	  Person per2 = null;	// 声明per2对象
	  per1 = new Person();	// 只实例化per1一个对象
	  per2 = per1 ;// 把per1的堆内存空间使用权给per2 
	  per1.name = "张三";// 设置per1对象的name属性内容
	  per1.age = 30;	// 设置per1对象的age属性内容
	// 设置per2对象的内容，实际上就是设置per1对象的内容
	  per2.age = 33;
	  System.out.print("per1对象中的内容 --> ") ;
	  per1.tell();		// 调用类中的方法
	  System.out.print("per2对象中的内容 --> ") ;
	  per2.tell();
	}
}

内存划分如下：