4_2、Java基本语法之对象的两个重要结构：属性与方法

于 2022-10-24 18:49:12 发布
阅读量391 收藏
点赞数
分类专栏： Java基础编程 文章标签： 1024程序员节
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/xiaosuxueJava/article/details/127419098
版权
本文详细讲解了Java中类的属性定义、变量分类，方法的作用、声明与返回值，重载方法的概念与判断，可变个数形参，值传递机制，递归方法的应用实例，以及如何使用和理解这些概念。涉及类的属性、方法的使用、重载和递归算法等内容。

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

一、属性

1、语法格式：

        修饰符  数据类型  属性名  =  初始化值 ;

        说明1: 修饰符
                常用的权限修饰符有：private、缺省、protected、public

                其他修饰符：static、final (暂不考虑)

        说明2：数据类型

                任何基本数据类型(如int、Boolean) 或 任何引用数据类型。

        说明3：属性名

                属于标识符，符合命名规则和规范即可。

举例：

class Student{
	public String name;
	private int age;
	String major;
	protected String interests;
}

2、变量的分类：成员变量与局部变量

对比：         属性(成员变量)  vs  局部变量
1.相同点：

        1.1、定义变量的格式相同：数据类型 变量名 = 变量值;
        1.2、只要是变量都需要先声明，后使用。
        1.3、变量都其对应的作用域。

2.不同点：

        2.1、声明的位置不同。
                属性直接声明在类的{ }内。
                局部变量声明在方法中、方法形参、代码块、构造器形参、构造器内部的变量

        2.2、关于权限修饰符的不同
                 属性：在定义属性时，用权限修饰符指明其权限。
                 常用的权限修饰符：private、public、缺省、protected ——>封装性
 
                 局部变量：不可以使用权限修饰符。

        2.3、默认初始化情况
                属性：属性在声明时，会默认的初始化值
                2.3.1.基本数据类型
                        整型（byte、short、int、long 0
                        浮点型(float、double)： 0.0
                        字符型(char)  0 或 '\u0000'
                        布尔型(boolean) false

                2.3.2.引用数据类型：null

                成员变量：没默认初始化值。在调用前必须显式给变量赋值才能使用。
 
        2.4在内存中的位置不同
                属性：加载在堆空间中
                成员变量：加载在栈空间中

补充：回顾变量的分类：

方式一：按数据类型分

 方式二：按声明的位置分

 

二、方法

一、方法的作用

        方法：应该描述类具的功能。

        比如：

                Math类的sqrt()、random()..
                Scanner类的xxxNext()..
                Arrays类的sort()、binarySreach()、toString()、equals()...

注意：Java里的方法不能独立存在，所有的方法必须定义在类里。

二、方法使用的说明：

1.举例

public void eat(){}
public void sleep(int hour){}
public String getName(){}
public String getNation(String nation){}

2.方法的声明
        权限修饰符 返回值类型 方法名(形参列表){
                方法体
        }

3.说明
        3.1关于权限修饰符：private、public、缺省、protected
        3.2关于返回值类型：返回值 vs 无返回值
                3.2.1有返回值：如果方法有返回值，则需要在方法声明时，指定返回值类型。方法中需要使用return关键字来返回相对于数据类型的常量或变量。“return 数据;”
                没返回值：如果方法没返回值，则需要使用void来修饰，一般的，方法中不需要使return关键字，如果使用，只能return;  表示结束方法。
 
                3.2.2定义方法该不该返回值？
                        题目要求、凭经验

        3.3方法名：遵循标识符命名规则规范，“见名知意”

        3.4形参列表：方法可以0个、1个或多个形参。
                3.4.1形参格式：数据类型1 形参1,数据类型2 形参2,...
                3.4.2怎么判断需不需要形参：题目要求、凭经验

        3.5方法体：设计方法的功能

 4.方法的使用：

                ①方法的使用，可以调用当前类的属性和方法。
                特殊的：方法A中再次调用方法A：递归方法。
                ②方法中不能再定义新的方法。

三、return关键字

        1、使用范围：使用在方法体中。
        2、作用：①结束方法。②针对返回值的方法，使用"return 数据"的形式返回数据。
        3、注意点：注意：return后不可以执行语句。

经典练习：

1、利用面向对象的编程方法，设计类Circle计算圆的面积。

class Circle{
	double radius;
	
	public double getArea(){
		return Math.PI * radius * radius;
	}
}

public class CircleTest {
	public static void main(String[] args){
		Circle c = new Circle();
		c.radius = 10;
		System.out.println("圆的面积为："+c.getArea());
	}
}

2、编写程序，声明一个method方法，在方法中打印一个10*8 的*型矩形， 再计算该矩形的面积，并将其作为方法返回值。在main方法中调用该方法， 接收返回的面积值并打印。

改进：在method方法提供m和n两个参数，方法中打印一个 m*n的*型矩形，并计算该矩形的面积， 将其作为方法返回值。在main方法 中调用该方法，接收返回的面积值并打印。

public class MethodTest {

	public static void main(String[] args) {
		MethodTest test = new MethodTest();
		int eare = test.method();
		System.out.println("矩形面积为：" + eare);
		
		int eare1 = test.method(10, 12);
		System.out.println("矩形面积为：" + eare1);

	}
	public int method(){
		for(int i=1;i<=10;i++){
			for(int j=1;j<=8;j++){
				System.out.print("*");
			}
			System.out.println();
		}
		
		return 10*8;
	}
	public int method(int m,int n){
		for(int i=1;i<=m;i++){
			for(int j=1;j<=n;j++){
				System.out.print("*");
			}
			System.out.println();
		}
		
		return m*n;
	}
}

3.对象数组题目： 定义类Student，包含三个属性：学号number(int)，年级state(int)，成绩 score(int)。 创建20个学生对象，学号为1到20，年级和成绩都由随机数确定。 问题一：打印出3年级(state值为3）的学生信息。 问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息

import java.util.Random;

public class StudentTest {
	public static void main(String[] args) {
		Student1[] stu = new Student1[20];
		StudentTest test = new StudentTest();
		
		for(int i=0;i<stu.length;i++){
			stu[i] = new Student1();
			stu[i].number = i+1;
			stu[i].state = (int)(Math.random() * (6+1));
			stu[i].score = (int)(Math.random() * (100));
		}
		test.print(stu);
		System.out.println("三年级的学生有：");
		test.FindState(stu, 3);
		System.out.println("*******************");
		test.sort(stu);
		test.print(stu);
	}

	/**
	* @Description 指定按成绩排序
	* @author suxintai
	* @date 2022年10月24日下午3:12:34
	* @param stu
	 */
	public void sort(Student1[] stu){
		for(int i=0;i<stu.length-1;i++){
			for(int j = 0;j<stu.length-1-i;j++){
				if(stu[j].score>stu[j+1].score){
					Student1 temp = stu[j];
					stu[j] = stu[j+1];
					stu[j+1] = temp;
				}
			}
		
		}
	}

	/**
	 * 
	 * @Description 遍历指定Student1对象数组
	 * @author suxintai
	 * @date 2022年10月24日下午3:07:25
	 * @param stu
	 */
	public void print(Student1[] stu){
		for(int i=0;i<stu.length;i++){
			System.out.println(stu[i].getIofo());
		}
	}
	/**
	 * 
	 * @Description 输出指定年级的学生信息
	 * @author suxintai
	 * @date 2022年10月24日下午3:10:06
	 * @param stu
	 * @param state
	 */
	public void FindState(Student1[] stu,int state){
		for(int i=0;i<stu.length;i++){
			if(stu[i].state == state){
				System.out.println(stu[i].getIofo());
			}
		}
	}
}

class Student1{
	int number;
	int state;
	int score;
	
	public String getIofo(){
		return ("学号:"+number+",年级："+state+",成绩："+score);
	}
}

四、方法的重载

1、定义：类中声明的方法名相同，但是参数列表不相同的多个方法构成方法的重载。

        “两同一不同”：同一个类、相同方法名。参数列表不同：参数个数不同、参数类型不同。

2、构成重载的举例：
        以下四个方法构成重载

    public void getSum(int i,int j){
        System.out.println(i + j);
    }
    public void getSum(double i,double j){ }
    public void getSum(String s,int i){ }
    public void getSum(int i,String s){ }

        不构成重载的举例：
        以下三个方法不构成重载

//    public int getSum(int i,int j){} 
//    private void getSum(int i,int j){}
//    public void getSum(int m,int n){}

3、如何判断是否构成方法的重载？
        ①“两同一不同”

        ②方法的重载跟权限修饰符、方法返回值类型、形参变量名都没关系。

4、如何确定类中某一个方法的调用：
        方法名——>形参列表

5、练习题

①定义三个重载方法FindMax()，第一个方法求两个int值中的最大值，第二个方 法求两个double值中的最大值，第三个方法求三个double值中的最大值， 并分别调用三个方法。

public class OverLoadTest {

	public static void main(String[] args) {
		OverLoadTest test = new OverLoadTest();
		System.out.println(test.FindMax(10, 52));
		System.out.println(test.FindMax(11.5, 31));
		System.out.println(test.FindMax(110, 21.1, 1.0));

	}
	
	public int FindMax(int m,int n){
		return ((m>n)?m:n);
	}
	
	public double FindMax(double m,double n){
		return ((m>n)?m:n);
	}
	
	public double FindMax(double m,double n,double x){
		return ((m>n)?((m>x)?m:x):(n>x)?n:x);
	}

}

五、可变个数形参的方法

1、使用说明：允许直接定义能和多个实参相匹配的形参。从而，可以用一种更简单的方式，来传递个数可变的实参。    
        1.0 、JavaSE 5.0 中提供了Varargs(variable number of arguments)机制.
    
        2.0 具体用法：
                2.1  格式：数据类型 ... 形参变量名
                2.2  当对象调用可变形参的方法时，传入的参数个数可以是0个、1个、2个...
                2.3    可变形参方法与本类中方法名相同，形参不相同的方法构成重载。
                2.4  可变形参方法与本类中方法名相同，形参为相同类型的数组的方法不构成重载，既不能共存。
                2.5  方法的参数部分可变形参，需要放在形参声明的最后
                2.6   在一个方法的形参位置，最多只能声明一个可变个数形参


2、举例说明：

    public void show(int i){
        System.out.println(i);
    }
    
    public void show(String s){
        System.out.println("show(String s)");
    }
    
    public void show(String ...strings ){
        System.out.println("show(String ...strings)");
    }
    //不能遇上一个方法共存
//    public void show(String[] strings ){
//        System.out.println("show(String ...strings)");
//    }


调用时：
    test.show(1);
    test.show("hello");
    test.show();.

 六、java的值传递机制

1、针对于方法内变量的赋值举例：

    public static void main(String[] args) {
        System.out.println("**********基础数据类型*********");
        int m = 10;
        int n = m;
        System.out.println("m = "+ m +",n = "+ n);
        n = 20;
        System.out.println("m = "+ m +",n = "+ n);
        
        
        System.out.println("**********引用数据类型*********");
        Order o1 = new Order();
        o1.orderId = 1001;
        Order o2 = o1;
        System.out.println("o1.orderId = "+ o1.orderId + ",o2.orderId = " + o2.orderId);
        o2.orderId = 1002;
        System.out.println("o1.orderId = "+ o1.orderId + ",o2.orderId = " + o2.orderId);
        
        
    }

运行结果：

2、针对于方法的参数概念
        形参：定义方法时，声明在小括号内的参数。
        实参：调用方法时，实际传入形参的数据。 

3、Java中参数传递机制：值传递
        规则：如果参数是基础数据类型，那么实参赋给形参的值就是实参所保存的数据值。
                   如果参数是引用数据类型，那么实参赋给形参的值就是实参所保存的地址值。

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);//10,20
		
		ValueTransferTest2 test = new ValueTransferTest2();
		test.swap(data);
		
		
//		int temp = data.m;
//		data.m = data.n;
//		data.n = temp;
		System.out.println("m = " + data.m + ",n = " + data.n);
	}
	
	public void swap(Data data){
		int temp = data.m;//temp = 10
		data.m = data.n;//m=20
		data.n = temp;//n=10
	}
}

class Data{
	int m;
	int n;
}

运行结果：

4、推广：变量的赋值
        ①如果变量是基础数据类型，那么赋值保存的是变量的数据值。
        ②如果变量是引用数据类型，那么赋值保存的是变量的地址值。

七、递归方法

1、定义：一个方法体内调用它自身。

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

举例：

//1.计算1-100之间所自然数的和
	public int getSum(int n){
		if(n == 1){
			return 1;
		}else{
			return n + getSum(n-1);
		}
	}
	
	//2.计算1-100所自然数的乘：n!
	public int getFactorial(int n){
			if(n == 1){
				return 1;
			}else{
				return n * getFactorial(n-1);
			}
		}
	
	//3.已知一个数列：f(0) = 1,f(1) = 4,f(n+2)=2*f(n+1) + f(n),其中n是大于0的整数，求f(10)的值。
	public int f(int n){
		if(n == 0){
			return 1;
		}else if(n == 1){
			return 4;
		}else{
			return 2 * f(n-1) + f(n-2);
		}
	}
	
	//4.斐波那契数列
	
	//5.汉诺塔
	
	//6.快排

以上问题都涉及到递归方法。

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值