Java2 2021.6.24

最新推荐文章于 2022-08-03 20:45:52 发布

芜湖A飘

最新推荐文章于 2022-08-03 20:45:52 发布

阅读量62

点赞数 1

分类专栏： Java

本文链接：https://blog.csdn.net/weixin_59568478/article/details/118186205

版权

Java 专栏收录该内容

14 篇文章 0 订阅

订阅专栏

本文详细介绍了Java中的方法和变量，包括静态方法与非静态方法的调用、this关键字的使用、方法参数传递机制、递归方法、方法重载以及局部变量和成员变量的区别。内容涵盖类变量和实例变量的访问、方法调用规则以及形参可变方法的实现。通过实例展示了如何在Java程序中灵活运用这些概念。

摘要由CSDN通过智能技术生成

静态方法访问普通方法

package practice;
import java.util.*;
public class Main{
	public void info() {//非静态方法，是属于实例的方法必须使用对象调用方法
		System.out.println("正在使用简单的info");
	}
	public static void main(String[] args)//静态方法
	{
		//info();没办法直接调用，要先创建实例；
		new Main().info();//利用主程序主类构建实例调用主类里函数
	}
}

this总是引用该构造器正在初始化的对象

package practice;
import java.util.*;
public class Main{
	public int foo;//定义foo成员变量
	public Main()//主类构造器
	{
		int foo=0;//在构造器里定义foo变量
		this.foo=6;//把构造器正在初始化的对象foo成员变量设定为6
	}
	public static void main(String[] args) {
		System.out.println(new Main().foo);
	}
}

this作为对象的默认引用使用时，程序可以像访问普通变量一样来访问这个this的引用，甚至可以把this当成普通方法的返回值

package practice;
import java.util.*;
public class Main{
	public int age;
	public Main grow() {
		age++;
		return this;//返回调用该方法的对象，this作为返回值可以连续多次调用一个方法
	}
	public static void main(String[] args)
	{
		Main it=new Main();
		it.grow()//连续调用同一个方法；
		.grow()
		.grow();
		System.out.println(it.age);
		
	}
}

关于方法
1、方法不能独立定义，方法只能在类体里定义
2、方法要么属于类本身，要么属于该类的一个实例
3、永远不能独立执行，必须使用类或对象作为调用者
4、没有static修饰的方法不属于类本身，只能通过实例来调用，因此不同的调用，结果可能不同

Java中实参值传入方法的方法：值传递：将实际参数值的副本（复制品）传入方法内，而参数本身不会受到影响，因此若要改变实参，需要返回值

package practice;
import java.util.*;
public class Main{
	public static void swap(int a,int b) {
		int tmp=a;
		a=b;
		b=tmp;
		System.out.println("jiaohuan"+a+b);//jiaohuan2312
	}
	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		int a=sc.nextInt();//12
		int b=sc.nextInt();//23
		swap(a, b);
		System.out.println("jiaohuan2"+a+b);//jiaohuan21223//并没有改变实际值
	}
}

改成调用的形式就可以改变实际值，看起来像直接调用，但其实不是，只是因为所有值引用的是同一个对象

package practice;
import java.util.*;
public class Main{
	public static void swap(S dw) {
		int tmp=dw.a;
		dw.a=dw.b;
		dw.b=tmp;
		System.out.println("jiaohuan"+dw.a+dw.b);//jiaohuan21
	}
	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		S dw=new S();
		dw.a=sc.nextInt();//1
		dw.b=sc.nextInt();//2
		swap(dw);
		System.out.println("jiaohuan2"+dw.a+dw.b);//jiaohuan221
	}
}
class S{
	int a;
	int b;
}

形参个数可变的方法

package practice;
import java.util.*;
public class Main{
	public static void test(int a,String...books)//在最后一个形参类型后面加三个点，则表明该形参能够接受多个参数值，可以传入多个参数，也可以是数组
	{//多个参数值被当做数组传入，个数可变的形参类型只能是最后一个，只能包含一个个数有变的形参
		for(String tmp:books)//foreach遍历，tmp相当于临时参量
		{
			System.out.println(tmp);
		}
		System.out.println(a);
	}
	public static void main(String[] args)
	{
		test(5,"fengkuang","你在搞什么");
	}
}
//public static void test(int a,String...books)=//这个不在乎你传入几个值
//public static void test(int a,String[] books)//这个必须传入的是一个数组

递归方法：在方法中调用其自身，一定要已知方向

方法重载：同一个类中定义多个同名方法但是形参不同

package practice;
import java.util.*;
public class Main{
	public void test() {//由于形参列表不同，系统自动区分
		System.out.println("无参数");
	}
	public void test(String a) {
		System.out.println(a);
	}
	public static void main(String[] args)
	{
		String a="就这？";
		new Main().test();
		new Main().test(a);
	}
}

遇到形参可变方法时，优先选择最佳选项

package practice;
import java.util.*;
public class Main{
	public void test(String...a) {
		System.out.println("形参可变的方法");
	}
	public void test(String a) {
		System.out.println("形参不可变的方法");
	}
	public static void main(String[] args)
	{
		String a="就这？";
		//形参不可变的方法
		new Main().test(a);//首先调用最符合选项
		//形参可变的方法
		new Main().test(a,a);
		new Main().test(String[] a);//此时传入数组调用形参可变test，即使只有一个参数
	}
}

局部变量：{//除形参之外，都必须显式初始化
1、形参（方法签名中定义的变量）
2、方法局部变量（在方法内定义）
3、代码块局部变量（在代码块内定义）
}

package practice;
import java.util.*;
public class Main{
	public static void main(String[] args){
		{
			int a;
			a=5;//该局部变量必须初始化以后才有效
			System.out.println(a);
		}
		//System.out.println(a);这里变量a不存在，因为a是局部变量只是代码块内有效
	}
}

成员变量：{
1、实例变量（不用static修饰）
2、类变量（用static修饰）
}
类变量特点：能通过类名和实例访问，若用实例访问值会随实例的调用而改变
类变量只能在静态初始化块里或者声明量时指定初始值。
实例变量特点：只能通过实例进行访问，只能改变实例引用的复制量，不改变实例变量的值
实例变量只能在非静态初始化块，声明该变量，或构造器中指定初始值。
由于这个实例并不拥有这个类变量，因此它访问的并不是这个实例的变量，依然是他访问的那个类的类变量。也就是说，如果通过一个实力修改了类变量的值，由于这个类变量不属于他，而属于该类变量对应的类，因此修改的是这个类的类变量，与通过类名修改类变量是一个效果，这会导致该类的其他实例来访问这个变量时也将获得修改以后的值

package practice;
import java.util.*;
public class Main{
	public static void main(String[] args)
	{
		System.out.println("1"+Person.eyeNum);//1 0
		Person p=new Person();
		System.out.println("2"+p.eyeNum+p.name);//2 0null
		p.name="疯了";
		p.eyeNum=2;//通过实例改变了类变量
		System.out.println("3"+p.eyeNum+p.name);//3 2疯了
		System.out.println("4"+Person.eyeNum);//4 2
		Person p2=new Person();
		System.out.println("5"+p2.eyeNum+p2.name);//5 2null//实例变量没有因为前实例变量的改变而改变
	}
}
class Person{
	public String name;//实例变量
	public static int eyeNum;//类变量
}

this可以用于当局部变量覆盖成员变量（两者同名）时在方法里调用实例变量

package practice;
import java.util.*;
public class Main{
	private String name="李刚";//实例变量
	private static double price=78.0; //类变量
	public static void main(String[] args) {
		int price=65;
		System.out.println(price);
		System.out.println(Main.price);
		new Main().info();
	}
	public void info() {
		String name="孙悟空";
		System.out.println(name);
		System.out.println(this.name);//将输出实例变量的值
	}
}