0基础学java-day6-（面向对象编程(基础部分)）_java从概念或叫法上看:成员变量=属性 = field(字段) (即成员变量是用来表示属-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_51580177/article/details/134363338

本文围绕Java开发展开，详细介绍了类与对象的区别、联系、创建及内存分配机制，阐述了成员方法的定义、调用、传参等内容，还涉及方法递归调用、重载、可变参数，以及作用域、构造方法和this关键字的使用，最后布置了课后作业。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一.类与对象的关系示意图

1.类和对象的区别和联系

1) 类是抽象的，概念的，代表一类事物,比如人类,猫类.., 即它是数据类型.
2) 对象是具体的，实际的，代表一个具体事物, 即是实例.
3) 类是对象的模板，对象是类的一个个体，对应一个实例

2.属性/成员变量/字段

从概念或叫法上看：成员变量 = 属性 = field(字段) （即成员变量是用来表示属性的，授课中，统一叫属性)
属性是类的一个组成部分，一般是基本数据类型,也可是引用类型(对象，数组)。比如我们前面定义猫类的 int age 就是属性

注意事项和细节说明


public class PropertiesDetail { 

	//编写一个main方法
	public static void main(String[] args) {
		//创建Person对象
		//p1 是对象名(对象引用)
		//new Person() 创建的对象空间(数据) 才是真正的对象
		Person p1 = new Person();

		//对象的属性默认值，遵守数组规则:
		//int 	0，short 0, byte 0, long 0, float 0.0,double 0.0，char \u0000，boolean false，String null
	
		System.out.println("\n当前这个人的信息");
		System.out.println("age=" + p1.age + " name=" 
				+ p1.name + " sal=" + p1.sal + " isPass=" + p1.isPass) ;
	}
}

class Person {
	//四个属性
	int age;
	String name;
	double sal;
	boolean isPass;
}

3.如何创建对象

1) 先声明再创建

Cat cat ; //声明对象 cat

cat = new Cat(); //创建

2) 直接创建

Cat cat = new Cat();

4.如何访问属性

5.类和对象的内存分配机制

5.1 Java 内存的结构分析

1) 栈：一般存放基本数据类型(局部变量)
2) 堆：存放对象(Cat cat , 数组等)
3) 方法区：常量池(常量，比如字符串)，类加载信息
4) 示意图 [Cat (name, age, price)

5.2 Java 创建对象的流程简单分析

1) 先加载 Person 类信息(属性和方法信息, 只会加载一次)
2) 在堆中分配空间, 进行默认初始化(看规则)
3) 把地址赋给 p , p 就指向对象
4) 进行指定初始化，比如 p.name =”jack” p.age = 10

二、成员方法

1基本介绍

在某些情况下，我们要需要定义成员方法 ( 简称方法 ) 。比如人类 : 除了有一些属性外 ( 年龄，姓名 ..), 我们人类还有一些行为比如: 可以说话、跑步 .., 通过学习，还可以做算术题。这时就要用 成员方法 才能完成。现在要求对 Person 类完善。

2成员方法快速入门


public class Method01 { 

	//编写一个main方法
	public static void main(String[] args) {
		//方法使用
		//1. 方法写好后，如果不去调用(使用)，不会输出
		//2. 先创建对象 ,然后调用方法即可
		Person p1 = new Person();
		p1.speak(); //调用方法
		p1.cal01(); //调用cal01方法
		p1.cal02(5); //调用cal02方法，同时给n = 5
		p1.cal02(10); //调用cal02方法，同时给n = 10
		
		//调用getSum方法，同时num1=10, num2=20
		//把 方法 getSum 返回的值，赋给 变量 returnRes
		int returnRes = p1.getSum(10, 20); 
		System.out.println("getSum方法返回的值=" + returnRes);
	}
}

class Person {
	
	String name;
	int age;
	//方法(成员方法)
	//添加speak 成员方法,输出 “我是一个好人”
	//老韩解读
	//1. public 表示方法是公开
	//2. void ： 表示方法没有返回值
	//3. speak() : speak是方法名， () 形参列表
	//4. {} 方法体，可以写我们要执行的代码
	//5. System.out.println("我是一个好人"); 表示我们的方法就是输出一句话
	
	public void speak() {
		System.out.println("我是一个好人");
	}

	//添加cal01 成员方法,可以计算从 1+..+1000的结果
	public void cal01() {
		//循环完成
		int res = 0;
		for(int i = 1; i <= 1000; i++) {
			res += i;
		}
		System.out.println("cal01方法 计算结果=" + res);
	}
	//添加cal02 成员方法,该方法可以接收一个数n，计算从 1+..+n 的结果
	//老韩解读
	//1. (int n) 形参列表， 表示当前有一个形参 n, 可以接收用户输入
	public void cal02(int n) {
		//循环完成
		int res = 0;
		for(int i = 1; i <= n; i++) {
			res += i;
		}
		System.out.println("cal02方法 计算结果=" + res);
	}

	//添加getSum成员方法,可以计算两个数的和
	//老韩解读
	//1. public 表示方法是公开的
	//2. int :表示方法执行后，返回一个 int 值
	//3. getSum 方法名
	//4. (int num1, int num2) 形参列表，2个形参，可以接收用户传入的两个数
	//5. return res; 表示把 res 的值， 返回
	public int getSum(int num1, int num2) {
		int res = num1 + num2;
		return res;
	}
}

3方法的调用机制原理

4.成员方法的好处

1) 提高代码的复用性
2) 可以将实现的细节封装起来，然后供其他用户来调用即可

5.成员方法的定义

1) 形参列表：表示成员方法输入 cal(int n) ， getSum(int num1, int num2)
2) 返回数据类型：表示成员方法输出, void 表示没有返回值
3) 方法主体：表示为了实现某一功能代码块
4) return 语句不是必须的。

6. 注意事项和使用细节

6.1访问修饰符 (作用是控制方法使用的范围)

如果不写默认访问，[有四种: public, protected, 默认, private], 具体在后面说

6.2返回数据类型

一个方法最多有一个返回值 [思考，如何返回多个结果返回数组 ]
返回类型可以为任意类型，包含基本类型或引用类型(数组，对象)
如果方法要求有返回数据类型，则方法体中最后的执行语句必须为 return 值; 而且要求返回值类型必须和 return 的值类型一致或兼容
如果方法是 void，则方法体中可以没有 return 语句，或者只写 return ;

6.3 方法名

遵循驼峰命名法，最好见名知义，表达出该功能的意思即可, 比如得到两个数的和 getSum, 开发中按照规范

6.4 形参列表

6.5 方法体

6.6 方法调用

7.类定义的完善

8.成员方法传参机制

8.1基本数据类型的传参机制

8.2 引用数据类型的传参机制

看一个案例 MethodParameter02.java

B 类中编写一个方法 test100，可以接收一个数组，在方法中修改该数组，看看原来的数组是否变化？会变化
B 类中编写一个方法 test200，可以接收一个 Person(age,sal)对象，在方法中修改该对象属性，看看原来的对象是否变化？会变化.

public class MethodParameter02{
	public static void main(String[] args) {
		B b = new B();
		int [] arr ={1,2,3};
		b.test100(arr);
		System.out.print("主方法的arr数组\t");
		for(int i=0;i<arr.length;i++)
		{
			System.out.print(arr[i]+"\t");
		}

		//测试
		Person p = new Person();
		b.test200(p);
		System.out.print("主方法的p.age=\t"+p.age);

	}
}

class Person{
	String name;
	int age;
}



class B{

	public void test100(int [] arr){
		arr[0] = 200;
		System.out.print("text100的arr数组");
		for(int i=0;i<arr.length;i++)
		{
			System.out.print(arr[i]+"\t");
		}
	}

	public void test200(Person p){
		p.age = 100000;
	}
}

结论及示意图

引用类型传递的是地址（传递也是值，但是值是地址），可以通过形参影响实参！

在看一个案例，下面的方法会对原来的对象有影响吗？

p=null 和 p = new Person(); 对应示意图

在方法中置空，只是断开了方法中的链接断开了，但是主方法中的链接并没有断掉。

三、方法递归调用

递归就是方法自己调用自己 , 每次调用时传入不同的变量 . 递归有助于编程者解决复杂问题 , 同时可以让代码变得简洁

1.递归能解决什么问题

2.递归举例

列举两个小案例 , 来帮助大家理解递归调用机制

1) 打印问题
2) 阶乘问题


public class Recursion01 { 

	//编写一个main方法
	public static void main(String[] args) {

		T t1 = new T();
		t1.test(4);//输出什么？ n=2 n=3 n=4
		int res = t1.factorial(5); 
		System.out.println("5的阶乘 res =" + res);
	}
}

class T {
	//分析
	public  void test(int n) {
		if (n > 2) {
			test(n - 1);
		} 
		System.out.println("n=" + n);
	}

	//factorial 阶乘
	public  int factorial(int n) {
		if (n == 1) {
			return 1;
		} else {
			return factorial(n - 1) * n;
		}
	}


}

3.递归重要规则

4.课堂练习

5.迷宫问题

建议自己画个图，根据代码逻辑走一遍，如果可走，则标记为2

public class MiGong{
	public static void main(String[] args) {
		//思路
		//1.创建迷宫 用二维数组表示 int [] [] map= new int[8][7];
		//2.规定map数组元素值: 0表示可以走 1表示有障碍
		int [] [] map = new int[8][7];
		//将障碍物状态设置为1
		for(int i = 0;i<7;i++)
		{
			map[0][i] = 1;
			map[7][i] = 1;
			map[i][0] = 1;
			map[i][6] = 1;
		}
		map[3][1] = 1;map[3][2] = 1;
		System.out.println("系统地图当前情况 ");
		for (int i = 0;i < 8;i++){
			for (int j = 0;j < 7;j++)
				System.out.print(map[i][j]+" ");
			System.out.println(" ");
		}

		//使用findWay
		T t1 = new T();
		t1.findWay(map,1,1);

		System.out.println("======找路的情况如下=========");
		for (int i = 0;i < 8;i++){
			for (int j = 0;j < 7;j++)
				System.out.print(map[i][j]+" ");
			System.out.println(" ");
		}

}

}

class T{
	//使用递归回溯思想来解决老鼠出迷宫问题
	//1.findWay就是专门来找出迷宫的路径
	//2.如果找到就返回true；否则返回false
	//3.map就是一个二维数组，用来表示迷宫
	//4.i,和j就是老鼠当前的位置
	//5.因为是递归找路径，所以我们规定map数组每个值的含义
	//	0.表示可以走，1表示障碍物，2表示能走通；3表示走过但是是死路
	//6.当map[6][5]=2;那么就表示找到通路，否则就可以继续找
	//7.确定老鼠找路的策略，下-右-上-左
	public boolean findWay (int [] [] map ,int i, int j){
		if (map[6][5] == 2)//说明已经找到路
		{
			return true;
		}
		else{
			if (map[i][j]==0){//当前位置为0，说明表示可以走
				//我们假定可以走通
				map[i][j]=2;
				//使用找路策略，来确定该位置是否是真的能走通
				if (findWay(map,i+1,j)){//先走下
					return true;
				}
				else if(findWay(map,i,j+1)){//走右边
					return true;
				}
				else if(findWay(map,i-1,j)){//走上边
					return true;
				}
				else if(findWay(map,i,j-1)){//走左边
					return true;
				}
				else{
					map[i][j]=3;
					return false;
				}
			}
			else{
				//map[i][j]=1,2,3;
				return false;
			}
		}
	}
}

6.汉诺塔

汉诺塔（又称河内塔）问题是源于印度一个古老传说的益智玩具。大梵天创造世界的时候做了三根金刚石柱子，在一根柱子上从下往上按照大小顺序摞着 64 片圆盘。大梵天命令婆罗门把圆盘从下面开始按大小顺序重新摆放在另一根柱子上。并且规定，在小圆盘上不能放大圆盘，在三根柱子之间一次只能移动一个圆盘

public class HanoiTower{
	public static void main(String[] args) {
		T t =new T();
		t.move(3,'A','B','C');
	}
}

class T{
	//方法
	//num 表示要移动的个数,a,b,c 分别表示A塔，B塔，C塔
	public void move(int num ,char a,char b,char c){
		//如果只有一个盘 num=1
		if (num ==1){
			System.out.println(a+"->"+c);
		}
		else{
			//如果有多个盘，可以看成两个，最下面和上面所有的盘
			//(1)先移动上面所有的盘到b，借助c
			move(num-1,a,c,b);
			//(2)移动下面的盘到c
			System.out.println(a+"->"+c);
			//(3)移动b上面所有的盘到c，借助a
			move(num-1,b,a,c);
		}
	}
}

四、方法重载

java 中允许同一个类中，多个同名方法的存在，但要求形参列表不一致！

1.重载的好处

减轻了起名的麻烦
减轻了记名的麻烦

2.快速入门案例

public class OverLoad01{
	public static void main(String[] args) {
		MyCalculator mc = new MyCalculator();
		System.out.println(mc.calculate(1,2));//运行了第一个方法
		System.out.println(mc.calculate(1。1,2));//运行了第三个方法
	}
}

class MyCalculator{
	//下面的方法构成了重载
	public int  calculate(int n1, int n2){
		return n1+n2;
	}

	public double  calculate(int n1, double n2){
		return n1+n2;
	}

	public double  calculate(double n1, int n2){
		return n1+n2;
	}
	public int  calculate(int n1, int n2,int n3){
		return n1+n2+n3;
	}
}

3.注意事项和使用细节

4.课堂练习题

五、可变参数

java 允许将同一个类中多个同名同功能但参数个数不同的方法，封装成一个方法。就可以通过可变参数实现

1.基本语法

2.快速入门案例

看一个案例类 HspMethod，方法 sum 【可以计算 2 个数的和，3 个数的和， 4. 5，。。】

//1. int... 表示接受的是可变参数，类型是 int , 即可以接收多个 int(0- 多 )

//2. 使用可变参数时，可以当做数组来使用即 nums 可以当做数组

//3. 遍历 nums 求和即可

public int sum(int... nums) {



        //System.out.println("接收的参数个数=" + nums.length);

        int res = 0;

        for(int i = 0; i < nums.length; i++) {

                res += nums[i];

        }

        return res;

}

3.注意事项和使用细节


public class VarParameterDetail { 

	//编写一个main方法
	public static void main(String[] args) {
		//细节: 可变参数的实参可以为数组
		int[] arr = {1, 2, 3};
		T t1 = new T();
		t1.f1(arr);
	}
}

class T {

	public void f1(int... nums) {
		System.out.println("长度=" + nums.length);
	}

	//细节: 可变参数可以和普通类型的参数一起放在形参列表，但必须保证可变参数在最后
	public void f2(String str, double... nums) {

	}
	//细节: 一个形参列表中只能出现一个可变参数
	//下面的写法是错的.
	// public void f3(int... nums1, double... nums2) {

	// }
}

4.课堂练习

public class VarParameterExercise{
	public static void main(String[] args) {
		HspMethod H = new HspMethod();
		System.out.println(H.showScore("林然",98,99,100));
		
	}
}

class HspMethod{
	public String showScore(String name , double... scores){
		double sum=0;
		for(int i=0;i<scores.length;i++)
			sum+=scores[i];
		return name+"的分数："+sum;
	}
}

六、作用域

1基本使用

public class VarScope{
	public static void main(String[] args) {
		
	}
}

class cat{
	    //全局变量：也就是属性，作用域为整个类体 Cat 类：cry eat 等方法使用属性
		//属性在定义时，可以直接赋值
	int age = 10; //指定的值是 10
		//全局变量(属性)可以不赋值，直接使用，因为有默认值，
	double weight; //默认值是 0.0
	public void hi() {
		//局部变量必须赋值后，才能使用，因为没有默认值
		int num = 1;
		String address = "北京的猫";
		System.out.println("num=" + num);
		System.out.println("address=" + address);
		System.out.println("weight=" + weight);//属性
	}
	public void cry(){
		//1. 局部变量一般是指在成员方法中定义的变量
		//2. n 和 name 就是局部变量
		//3. n 和 name 的作用域在 cry 方法中
		//int n = 10;
		String name = "jack";
		System.out.println("在 cry 中使用属性 age=" + age);
	}
	public void eat() {
		System.out.println("在 eat 中使用属性 age=" + age);
		//System.out.println("在 eat 中使用 cry 的变量 name=" + name);//错误
	}
}

2.注意事项和细节使用

七、构造方法/构造器

我们来看一个需求：前面我们在创建人类的对象时，是先把一个对象创建好后，再给他的年龄和姓名属性赋值，如果现在我要求，在创建人类的对象时，就直接指定这个对象的年龄和姓名，该怎么做? 这时就可以使用构造器。

1基本语法

构造器的修饰符可以默认，也可以是 public protected private
构造器没有返回值
方法名和类名字必须一样
参数列表和成员方法一样的规则
构造器的调用, 由系统完成

2.基本介绍

构造方法又叫构造器(constructor)，是类的一种特殊的方法，它的主要作用是完成对新对象的初始化。它有几个特点：

方法名和类名相同
没有返回值
在创建对象时，系统会自动的调用该类的构造器完成对象的初始化

3.快速入门

现在我们就用构造方法来完成刚才提出的问题:在创建人类的对象时，就直接指定这个对象的年龄和姓名


public class Constructor01 { 

	//编写一个main方法
	public static void main(String[] args) {
		//当我们new 一个对象时，直接通过构造器指定名字和年龄
		Person p1 = new Person("smith", 80);
		System.out.println("p1的信息如下");
		System.out.println("p1对象name=" + p1.name);//smith
		System.out.println("p1对象age=" + p1.age);//80
	}
}

//在创建人类的对象时，就直接指定这个对象的年龄和姓名
//
class Person {
	String name;
	int age;
	//构造器
	//老韩解读
	//1. 构造器没有返回值, 也不能写void
	//2. 构造器的名称和类Person一样
	//3. (String pName, int pAge) 是构造器形参列表，规则和成员方法一样
	public  Person(String pName, int pAge) {
		System.out.println("构造器被调用~~ 完成对象的属性初始化");
		name = pName;
		age = pAge;
	}
}

4.注意事项和使用细节


public class ConstructorDetail { 

	//编写一个main方法
	public static void main(String[] args) {
		Person p1 = new Person("king", 40);//第1个构造器
		Person p2 = new Person("tom");//第2个构造器

		Dog dog1 = new Dog();//使用的是默认的无参构造器

	}
}
class Dog {
	//如果程序员没有定义构造器，系统会自动给类生成一个默认无参构造器(也叫默认构造器)
	//使用javap指令 反编译看看
	/*
		默认构造器
		Dog() {
			
		}
	 */
	//一旦定义了自己的构造器,默认的构造器就覆盖了，就不能再使用默认的无参构造器，
	//除非显式的定义一下,即:  Dog(){}  写 (这点很重要)
	//
	public Dog(String dName) {
		//...
	}
	Dog() { //显式的定义一下 无参构造器

	}
}

class Person {
	String name;
	int age;//默认0
	//第1个构造器
	public Person(String pName, int pAge) {
		name = pName;
		age = pAge;
	}
	//第2个构造器, 只指定人名，不需要指定年龄
	public Person(String pName) {
		name = pName;
	}
}

5.课堂练习题


public class ConstructorExercise { 

	//编写一个main方法
	public static void main(String[] args) {
		Person p1 = new Person();//无参构造器

		//下面输出 name = null, age = 18
		System.out.println("p1的信息 name=" + p1.name + " age=" + p1.age);

		Person p2 = new Person("scott", 50);
		//下面输出 name = scott, age = 50
		System.out.println("p2的信息 name=" + p2.name + " age=" + p2.age);

	}
}

/**
 * 在前面定义的Person类中添加两个构造器:
 * 第一个无参构造器：利用构造器设置所有人的age属性初始值都为18
 * 第二个带pName和pAge两个参数的构造器：
 * 使得每次创建Person对象的同时初始化对象的age属性值和name属性值。
 * 分别使用不同的构造器，创建对象.
 */

class Person {
	String name;//默认值 null
	int age;//默认 0
	//第一个无参构造器：利用构造器设置所有人的age属性初始值都为18
	public Person() {
		age = 18;//
	}
	//第二个带pName和pAge两个参数的构造器
	public Person(String pName, int pAge) {
		name = pName;
		age = pAge;
	}
}

6.对象创建的流程分析

八、this 关键字

1.了解This


public class This01 { 

	//编写一个main方法
	public static void main(String[] args) {

		Dog dog1 = new Dog("大壮", 3);
		System.out.println("dog1的hashcode=" + dog1.hashCode());
		//dog1调用了 info()方法
		dog1.info(); 

		System.out.println("============");
		Dog dog2 = new Dog("大黄", 2);
		System.out.println("dog2的hashcode=" + dog2.hashCode());
		dog2.info();
	}
}

class Dog{ //类

	String name;
	int age;
	// public Dog(String dName, int  dAge){//构造器
	// 	name = dName;
	// 	age = dAge;
	// }
	//如果我们构造器的形参，能够直接写成属性名，就更好了
	//但是出现了一个问题，根据变量的作用域原则
	//构造器的name 是局部变量，而不是属性
	//构造器的age  是局部变量，而不是属性
	//==> 引出this关键字来解决
	public Dog(String name, int  age){//构造器
		//this.name 就是当前对象的属性name
		this.name = name;
		//this.age 就是当前对象的属性age
		this.age = age;
		System.out.println("this.hashCode=" + this.hashCode());
	}

	public void info(){//成员方法,输出属性x信息
		System.out.println("this.hashCode=" + this.hashCode());
		System.out.println(name + "\t" + age + "\t");
	}
}

2.深入理解 this

this就是当前对象

3.this 的注意事项和使用细节

this 关键字可以用来访问本类的属性、方法、构造器
this 用于区分当前类的属性和局部变量
访问成员方法的语法：this.方法名(参数列表);

访问构造器语法：this(参数列表); 注意只能在构造器中使用(即只能在构造器中访问另外一个构造器, 必须放在第一条语句)
this 不能在类定义的外部使用，只能在类定义的方法中使用

4.this 的课堂案例

定义 Person 类，里面有 name、age 属性，并提供 compareTo 比较方法，用于判断是否和另一个人相等，提供测试类 TestPerson 用于测试, 名字和年龄完全一样，就返回 true, 否则返回 false


public class TestPerson { 

	//编写一个main方法
	public static void main(String[] args) {

		Person p1 = new Person("mary", 20);
		Person p2 = new Person("mary", 20);

		System.out.println("p1和p2比较的结果=" + p1.compareTo(p2));
	}
}

/*
定义Person类，里面有name、age属性，并提供compareTo比较方法，
用于判断是否和另一个人相等，提供测试类TestPerson用于测试, 
名字和年龄完全一样，就返回true, 否则返回false

 */
class Person {
	String name;
	int age;
	//构造器
	public Person(String name, int age) {
		this.name = name;
		this.age = age;
	}
	//compareTo比较方法
	public boolean compareTo(Person p) {
		//名字和年龄完全一样
		// if(this.name.equals(p.name) && this.age == p.age) {
		// 	return true;
		// } else {
		// 	return false;
		// }
		return this.name.equals(p.name) && this.age == p.age;
	}
}