Java学习（4）—类与对象

expecto
45 阅读12分钟

类

类的声明

class People{
......
}

People为类名，要遵循标识符规定且根据编程风格，类名为拉丁字母时则首字母应大写，比如ChineseMade

类体

class Ladder{
	double above;
	double bottom;
	double height;
	double getArea(){
		return (above+bottom)*height/2;
	}#类体的内容
}

{......}即为类体

成员变量

class Ladder{
	#double above;
 	double bottom;
	double height;#成员变量的声明
	double getArea(){
		return (above+bottom)*height/2;
	}
}

成员变量的默认值

如：boolean对应false； byte,short,int,long对应0； char对应'\0'(空字符)； float,double对应0.0； 对于引用型变量对应null

编程风格

  1. 一行只声明一个变量。
  2. 遵循标识符规定。

方法

方法头

int speak(){                   //无参数的方法头
    return 23;
}
int add(int x,int y){          //有参数的方法头
    return x+y;

方法体

int add(int x,int y){          
    int z=5;     //声明局部变量   
    z=x+y+z;
    return z;
}

区分成员变量和局部变量

当局部变量的名字和成员变量的名字相同时，则成员变量在这个方法内暂时失效。 如想使用暂时失效的那个成员变量，则必须使用关键字this 比如：

class Tom{
    int x=10,y;
    void f(){
    int x=5;
    y=x+this.x;             //y得到的值为15
    }
}

局部变量没有默认值

需要注意的问题

mindmap
      类体的内容
          变量的声明
          方法的定义

声明成员变量时可赋予初值，但赋值语句只能出现在方法体中， 如：

class A{
    int a;
    float b;
    a=12;            //非法
    b=12.56f;        //非法
}

类的UML图

对于：

class Ladder{
	double above;
	double bottom;
	double height;
	double getArea(){
		return (above+bottom)*height/2;
	}
}

UML图： 第一层名字层 第二层变量层 第三层方法层

Ladder
above:float bottom:float height:float
getArea():double

构造方法与对象的创建

构造方法

构造方法没有类型

class Point{
    int x,y;
    Point(){                      //是构造方法
    x=1;
    y=1;
    }
    void Point(int a,int b){      //不是构造方法
    x=a;
    y=b;
    }
}

创建对象

对象的声明

格式： 类的名字 对象名字 例如：

Ladder ladder;

为声明的对象分配变量

ladder= new Ladder();

使用对象

使用访问符"." 例如：

Ladder ladder= new Ladder();
	ladder.above= 10.798;
	ladder.bottom=156.65;
	ladder.height=18.12;
	area =ladder.getArea();
	System.out.println("梯形的面积:"+area);

对象的引用和实体

对于同一个类的两个对象object1和object2，允许进行如下的赋值操作：

object1=object2；

类与程序的基本结构

mindmap
      Java应用程序
          源文件
            主类
            类
          源文件
            主类
            类

实操：

1. 打开记事本三次，分别编辑、保存以下三个Java源文件

image.png

image.png

image.png

image.png 注意：保存时文件名需要加入".java",保存类型改为‘所有文件’，编码改为‘UTF-8’

2.在命令行窗口中进入上述目录，并编译

win+r，再输入cmd，打开命令行窗口 以上述为例， Example4_5.java保存的位置在 D:\Java\chapter4 中，

由于输出中有中文，所以命令行需编译：javac -encoding UTF-8 文件名.java 若无，则编译：javac 文件名.java

整个编译过程如下图所示：(划黄线部分为输入部分)

屏幕截图 2025-10-15 204435.png

参数的传值

参数属于局部变量

传值机制

形参：方法的参数

实参：向其传值的变量或常量

改变实参的值不会影响形参的值

基本数据类型参数的传值

class Rect{
	double width;
	double height;
        void set(double x,double y){
        width=x;
        height=y;
        }
	double getArea(){
		double area=width*height;
		return area;
	}
}
public class Example4_5{
	public static void main(String args[]){
	Rect ractangle =new Rect();
	double m=109.87;
	double n=25.18;
        ractangle.set(m,n);    //将m，n的值传递给x，y
	double area =ractangle.getArea();
	System.out.println("矩形的面积:"+area);
	}
}

引用类型参数的传值

一个类声明的两个对象如果具有相同的引用，两者就具有相同的变量

可变参数

形式：

public void g(double a,int ... x)//"..."表示若干个参数，这些参数类型必须相同，x是可变参数的参数代表

例如：

public int getSum(int... x){
    int sum=0;
    for(int i=0;i<x.length;i++){
        sum=sum+x[i];
    }
    return sum;
}

其中循环语句可更改为：

for(int param:x){
    sum=sum+param;
}

对象的组合

组合与复用

通过组合对象来复用方法的特点：

1.该方法也被称为“黑盒复用”，因为当前对象只能委托所包含的对象调用其方法，但对方法的细节一无所知。

2.当前对象随时可以更换所包含的对象，属于弱耦合关系。

3.所包含的对象的引用发生变化并不影响当前对象的引用，因为变化前的实体不被释放，仍然被当前对象所引用。

如图：

2c817af2657ffd70b37eb45e2f50627e.jpg

类的关联关系和依赖关系的UML图

关联关系

A类的成员变量是用B类声明的对象，即A类的对象关联于B类的对象或A类的对象组合了B类的对象。

如图：

dae44a22d2eaaf2a914a559528506c6c.jpg

依赖关系

A类中某个方法的参数是用B类声明的对象或某个方法返回的数据类型是B类对象，即A依赖于B。

如图：

实例成员与类成员

实例变量和类变量的声明

mindmap
      成员变量
          实例变量
            成员变量不用static修饰
          类变量
            类变量用static修饰

⚠️不能用static修饰局部变量

实例变量和类变量的区别

1.不同对象的实例变量互不相同

2.所有对象共享类变量

3.通过类名直接访问类变量

实例方法和类方法的定义

同理，类方法需加static关键词修饰

实例方法和类方法的区别

1.对象调用实例方法

2.类名调用类方法

3.设计类方法的原则 对于类方法，不必创建对象就可以用类名直接调用。创建对象导致类中的实例变量被分配内存空间。

方法重载

方法重载的语法规则

方法重载：在一个类中可以有多个方法具有相同的名字，但这些方法的参数必须不同

即满足以下条件之一：

1.参数的个数不同

2.参数个数相同但类型不同

避免重载出现歧义

重载方法之间必须保证相互的参数不同

this关键字

可以出现在实例方法和构造方法中，但不可以出现在类方法中

在构造方法中使用this

代表使用该构造方法所创建的对象

在实例方法中使用this

实例变量： this.成员变量

类变量： 类名.成员变量

比如：

class A{
    int x;
    static int y;
    void f(){
    this.x = 100;
    A.y = 200;
    }
}

方法同理

包

使用包名可以有效地区分名字相同的类

包语句

一般格式:

package 包名;

注意:

1.package语句作为Java源文件中的第一个语句，为该源文件中声明的类指定包名。

2.包名可以是一个合法的标识符，也可以是若干个标识符加“.”分隔而成，如:package sun.com.cn;

有包名的类的存储目录

如果一个类有包名，就不能在任意位置存放。

例如:

package tom.jja

则存储文件的目录中必须包含结构“…\tom\jja”

编译: 比如

C:\1000>javac tom\jja\源文件    //必须到“\tom\jja”的上一层目录中去运行源文件

运行有包名的主类

必须到“\tom\jja”的上一层目录中去运行主类 如： C:\1000>javac tom.jja.主类名

主类必须使用全名，即“包名.主类名”

例子：

image.png image.png

编译

法一： image.png 法二： image.png

其中“-encoding UTF-8”用于指定源文件编码格式的选项，若输出中没有出现中文，可忽略。

编译通过后，出现

image.png

运行

在运行程序时必须回到tom\jja的上一层目录中来执行

如果需要连续返回多层，可以多次执行 cd ..，或者直接指定目标路径（比如从 D:\Java\tom\jja 回到 D:\Java，可以执行 cd D:\Java）

如：

image.png

import语句

引入类库中的类

使用import语句可以引入包中的类和接口 如果要引入一个包中的所有类，则可以用通配符“*”来代替： import java.util.*; 而import java.util.Date;只是引入包中的Date类

例如：

image.png

image.png

引入自定义包中的类

比如：import tom.jja.*;

有包名的源文件

包名路径左对齐

无包名的源文件

包名路径和源文件左对齐

访问权限

私有变量和私有方法

用关键词private修饰,不能被其他类所访问

公有变量和公有方法

用关键词public修饰,能被其他类所访问

友好变量和友好方法

不用关键词public,private,protected修饰

  • 访问范围：

    • 仅能在当前类内部被访问。
    • 仅能在同一包中的其他类中被访问（无论是否是子类）。
    • 不同包中的类（包括子类）都无法访问。

受保护的成员变量和方法

用关键词protected修饰

  • 访问范围：

    • 能在当前类内部被访问。
    • 能在同一包中的其他类中被访问（与友好成员相同）。
    • 不同包中的子类可以访问（通过子类的实例或子类内部访问父类的 protected 成员）。
    • 不同包中的非子类无法访问。

public类和友好类

1. public 类

  • 定义：使用 public 修饰符的类，例如 public class MyClass { ... }。

  • 访问范围：

    • 可以被任何包中的任何类访问（前提是该类所在的包被正确导入）。

  • 特殊规则：

    • 一个 Java 源文件（.java文件）中最多只能有一个public类，且该类的类名必须与源文件的文件名完全一致（包括大小写）。例如，public class Test 必须放在 Test.java 文件中。

2. 友好类（默认访问权限的类）

  • 定义：没有使用任何访问修饰符的类，例如 class MyClass { ... }。

  • 访问范围：

    • 仅能被同一包中的其他类访问。
    • 不同包中的类无法访问（即使导入包也不行）。

  • 特殊规则：

    • 一个 Java 源文件中可以有多个友好类，且类名无需与文件名一致。

基本类型的类封装

1. 对应关系

8 个基本类型→8 个包装类，重点记最常用的：

  • int → Integer（唯一特殊，不是首字母大写）
  • char → Character（也是特殊）
  • 其他：double→Double、boolean→Boolean 等（首字母大写）

2. 最常用的功能

  • 字符串转基本类型：比如 Integer.parseInt("123") 把字符串转成 int。
  • 基本类型转字符串：Integer.toString(123) 或直接 123 + ""。

3. 自动装箱 / 拆箱

  • 装箱：基本类型自动变包装类，比如 Integer a = 10;。
  • 拆箱：包装类自动变基本类型，比如 int b = a;。

坑：包装类可以为null，拆箱时如果是null会报错（NullPointerException）。

4. 缓存机制

Integer、Byte等会缓存 -128~127 之间的值：

  • 比如 Integer a=100; Integer b=100;，a==b 结果是 true（用缓存的同一个对象）。
  • 但 a=200; b=200;，a==b 是 false（超出范围，新建对象）。

var局部变量

  1. 只能用于局部变量

    public void test() {
    var num = 10; // 正确：局部变量
    var str = "hello"; // 正确
}

// 错误用法（编译不通过）：
var name; // 必须声明时初始化（否则无法推断类型）
class MyClass {
    var age; // 不能用于成员变量
}

  2. 自动推断类型

变量的类型由初始化值决定，一旦确定就不可变（强类型特性不变）。 必须声明时初始化。

  1. 简化代码，不影响性能

对象数组

Student [] stu;
stu = new Student[10];

使用前需要stu[0]= new Student();

jar文件

文档性质的jar文件

即代码的说明书打包文件 例子：

image.png 位置：D:\Java\ch4\sohu\com

image.png 位置：D:\Java\ch4\sun\hello\moon

屏幕截图 2025-10-19 195201.png 1. 编写清单文件

比如：qingdan.mf image.png 位置：D:\Java\ch4

注意：保存时编码选择ANSI，保存类型选择所有文件

2. jar命令

屏幕截图 2025-10-19 200734.png 生成： image.png 3.使用jar文件中的类

  • 源文件：

image.png 位置： D:\Java\ch4\tom\jiafei

  • 编译：

屏幕截图 2025-10-19 201115.png

  • 运行：

屏幕截图 2025-10-19 201215.png

可运行的jar文件

可运行的JAR文件（Runnable JAR）是一种特殊的JAR包，它包含了可直接执行的Java程序，不需要额外解压或手动指定主类就能运行，是Java程序分发和部署的常用形式。

核心特点：

  1. 包含程序所有依赖

里面不仅有编译后的.class文件，还可能包含程序运行所需的其他资源（如配置文件、图片等），甚至可以打包第三方依赖库。

  1. 指定了主类

必须在JAR包的META-INF/MANIFEST.MF清单文件中，通过Main-Class属性指定程序的入口类（即包含main方法的类），例如：

    Manifest-Version: 1.0 
    Main-Class: com.example.MyMain // 主类全限定名（包名+类名）

如何运行？

直接用java -jar命令即可，无需手动指定主类： java -jar 文件名.jar

如何创建？

  1. 手动打包（命令行）
  • 先编译Java文件得到.class文件；
  • 编写清单文件（如manifest.mf），指定Main-Class；
  • 用jar命令打包： cmd jar cfm 可运行.jar manifest.mf 所有.class文件及资源
  1. IDE自动生成 IDE（如IDEA、Eclipse）提供可视化操作，直接选择“导出可运行JAR”，自动处理主类和依赖打包，更简单。

关键作用：

  • 方便分发：一个文件包含所有内容，用户拿到后直接运行，无需配置环境或手动找类。
  • 标准化部署：确保程序在不同环境中以相同方式运行，减少配置错误。 总结：可运行JAR是Java程序的“绿色执行包”，通过内置主类信息，实现一键运行，是Java程序分发的标准方式。

文档生成器

指的是 javadoc 工具，它是 JDK 自带的命令行工具，用于从 Java 源代码的注释（特殊格式的注释）中自动生成HTML 格式的 API 文档。

核心作用：

  • 从代码注释自动生成结构化文档（类似 Java 官方 API 文档的风格）。
  • 保持文档与代码同步：修改代码注释后，重新生成文档即可更新，避免 “文档与代码脱节”。

基础用法（命令行）：

  1. 在代码中写规范注释使用 /** ... */ 格式的注释（文档注释），并通过标签（如 @param、@return）说明细节：
/**
* 计算两个整数的和 
* @param a 第一个整数 
* @param b 第二个整数 
* @return 两个整数的和 
*/ 
public static int add(int a, int b) { 
return a + b; 
}

2. 运行 javadoc 命令生成文档

基本语法javadoc [选项] 源文件.java

例如，为 MyClass.java 生成文档，并输出到 docs 文件夹： javadoc -d docs MyClass.java

常用标签

image.png

avatar
文章
阅读
粉丝