简单Java程序2

最新推荐文章于 2024-01-03 16:53:39 发布

请你吃颗糖吧

最新推荐文章于 2024-01-03 16:53:39 发布

阅读量161

点赞数

文章标签： java 编程语言字符串算法

本文链接：https://blog.csdn.net/kksdw/article/details/104965697

版权

数组

（1）

public class hk1 {
	public static void main(String[] args) {
		int hka[]= {1,3,5};
		int hka2[]=new int[] {2,4,6};
		int hka3[]=new int[3] ;//没有指明长度，将会创建3个可以存放int变量的内存空间，初始值为0
		System.out.println(hka[0]);
		System.out.println(hka2[0]);
		System.out.println(hka3[0]);
	}
}

结果
在这里插入图片描述

局部变量

public class hk2 {
	public static void main(String[] args) {
		//  java的变量类型；只要是局部变量一定存储在栈（冯诺依曼决定的：计算机体系结构是他定义和实现的
		int hkx=10;//hkx是main函数里面定义的变量，属于基本数据类型局部变量，存储在栈，hkx存储的就是10
		String hks="hello";//hks是main函数里面定义的变量，属于引用数据类型局部变量，存储在栈，hks存储的是hello的地址
		int hky=10;
		String hksy="hello";
		System.out.println(hkx==hky);
		System.out.println(hks==hksy);
	}
}

局部变量String


public class hk3 {
	public static void main(String[] args) {
		String hks1="hello";//字符串常量在静态区
		String hks2=new String("hello");//java代码中只要看到new关键字申请的内存都是在堆
		String hks3=new String("hello");
		
		System.out.println(hks1==hks2);//比较的是s1存储的地址和s2存储的地址
		System.out.println(hks2==hks3);//比较的是s2存储的地址和s3存储的地址
		System.out.println(hks1.equals(hks2));//比较的是具体的字符序列
		System.out.println(hks2.equals(hks3));
	}
}

equals():用来比较方法两个对象的内容是否相等。
注意：equals()方法不能用于基本数据类型的变量，如果没有对equals()方法进行重写，则比较的是引用类型变量所指向的对象的地址。
String类型有两种内存方式：
(1) String str = “string”; //是将变量值存放到常量池
(2) String str2 = new String(“string”);//是在堆内存中
结果
在这里插入图片描述

局部变量int/Interer


public class hk4 {
	public static void main(String[] args) {
		int hka=1;
		Integer hka2=1;//a2存储的是源代码中 new Integer(1)的地址
		Integer hka3=1;//a3存储的也是源代码中 new Integer(1)的地址
		Integer hka4=300;//源代码中不在new Integer(-128)到new Integer(127)的对象，是重新new出来的
		Integer hka5=300;
		Integer hka6=new Integer(300);
		Integer hka7=new Integer(1);
		System.out.println(hka==hka2);//比较具体整数值，因为a是基本数据类型int
		System.out.println(hka2==hka3);//比较地址值，因为a2,a3是引用数据类型
		System.out.println(hka2==hka7);//比较地址值，因为是引用数据类型
		System.out.println(hka4==hka5);//比较地址值，因为是引用数据类型
		System.out.println(hka4==hka6);//比较地址值，因为是引用数据类型
	}
}

int 和Integer在进行比较的时候，Integer会进行拆箱，转为int值与int进行比较。
Integer与Integer比较的时候，由于直接赋值的时候会进行自动的装箱，那么这里就需要注意两个问题，一个是-128<= x<=127的整数，将会直接缓存在IntegerCache中，那么当赋值在这个区间的时候，不会创建新的Integer对象，而是从缓存中获取已经创建好的Integer对象。二：当大于这个范围的时候，直接new Integer来创建Integer对象。
new Integer(1) 和Integer a = 1不同，前者会创建对象，存储在堆中，而后者因为在-128到127的范围内，不会创建新的对象，而是从IntegerCache中获取的。那么Integer a = 128, 大于该范围的话才会直接通过new Integer（128）创建对象，进行装箱。

下面我们对情况进行逐一分析
第一个情况

Integer i = new Integer(128);
Integer i2 = 128;
//结果是false

i 是创建的一个Integer的对象，取值是128。
i2 是进行自动装箱的实例，因为这里超出了-128–127的范围，所以是创建了新的Integer对象。

那么i和i2都是Integer的对象咯。存储在堆中，分配的地址不同，在使用==进行判读的时候，由于双方都是对象，所以比较对象的地址是不是相同，这里的地址是不同的，因为new的时候会在堆中重新分配存储空间。

第二种情况

Integer i3 = new Integer(127);
Integer i4 = 127;
//结果为false

i3 是创建的一个Integer的对象，取值是127.
i4 是进行自动装箱后生成的Integer的对象，其值-128<= i4 <= 127，所以在这里会与第一种情况有所不同，这个i4对象直接取缓存IntegerCache中的对应的对象，当然了也是对象。

那么i3和i4也都是对象咯，而且一个是缓存中的，一个自己new的，既然是对象那么==会比较其地址，因为都new出来的对象（一个是自己new出来的，一个是IntegerCache中new出来的对象），那么自然这两种情况下，在堆中分配的地址是不同的。

第三种情况

Integer i5 = 128;
Integer i6 = 128;
//结果为false

**i5是自动装箱产生的Integer的对象，但是其大小超过了范围：-128<=A <=127，那么，这里会直接自己创建该对象即：new Integer(128);

i6和i5类似的原理。

显然这两个对象都是new出来，在堆中的地址值是不同的，那么==的时候判读其地址是不是相等，也就不一样了。**

第四种情况

Integer i7 = 127;
Integer i8 = 127;
//结果为true

i7、i8是自动装箱产生的对象，其值都是127，那么这里很特殊的是127正好在-128<=i7<=127这个范围内的，那么会去IntegerCache中取，既然都是去IntegerCache中去取，那么自然该对象应该是一个对象，那么再堆中的地址应该是一样的，所以在判读两个对象是不是== 的时候，会输出true

类变量/实例变量Jkj

class Jkj{
	static int hki;//基本数据类型
	int hkj;
	static String hks1;//引用数据类型
	String hks2;
}

public class hk5 {
	public static void main(String[] args) {
		Jkj hkj1=new Jkj();//Jkj()是构造函数，和类同值且没有返回值，不管类中有没有定义，默认都会存在一个无参数的构造函数
	    Jkj hkj2=null;
		hkj1.hks2="abc1";
	    hkj1.hks1="abc_cba";
	    System.out.println(hkj1.hks1);
	    System.out.println(hkj2.hks1);
	    hkj2=new Jkj();
	    hkj2.hks2="abc2";
	    hkj2.hks1="abc_nba";
	    System.out.println(hkj1.hks1 +","+hkj1.hks2);
	    System.out.println(hkj2.hks1 +","+hkj2.hks2);
	}
}

结果
在这里插入图片描述
类变量也叫静态变量，也就是在变量前加了static 的变量；

实例变量也叫对象变量，即没加static 的变量；

类变量和实例变量的区别在于：类变量是所有对象共有，其中一个对象将它值改变，其他对象得到的就是改变后的结果；而实例变量则属对象私有，某一个对象将其值改变，不影响其他对象；

函数判断纯数字组成，并测试

public class hk6 {
	//比如我们要判断用户输入的字符串必须是纯数字字符组成
	static boolean isNumStr(String str) {
		if (str==null ||  str.length()==0) {
		return false;	
		}
	
	for(int i=0;i < str.length();i++) {
		char hkch=str.charAt(i);
		if(! (hkch>='0'&& hkch<='9')) {
			return false;
		}
	}
	return true;
}
	public static void main(String[] args) {
	System.out.println(isNumStr(null));	
	System.out.println(isNumStr(""));	
	System.out.println(isNumStr("1111a"));	
	System.out.println(isNumStr("aa"));	
	System.out.println(isNumStr("11.11"));	
	System.out.println(isNumStr("111"));	
	}
}

用static修饰person效果

//java怎么表示一个人,用static来表示会是什么情况
class Person{
	static int hkid;
	static String hksname;
	static int hkage;
	static String hksex;
}


public class hk7 {
	public static void main(String[] args) {
		Person 张三=new Person();
		张三.hkid=10001;
		张三.hksname="张三";
		Person 李四=new Person();
		李四.hkid=10002;
		李四.hksname="李四";
		System.out.println("id"+张三.hkid+",sname="+张三.hksname);
		System.out.println("id"+李四.hkid+",sname="+李四.hksname);
		//因为用static修饰的数据是跟着类走的，所以就表达不出两个人的信息
	}

}

结果
在这里插入图片描述

非static修饰Stu效果

class hkStu{
	int hkid;
	String hksname;//非static修饰的数据是跟着对象走的
	hkStu(){
	}
	hkStu(int yyxid,String yyxsname){
		this.hkid=yyxid;//this表示当前new出来的实例（就是指当前对象）
		this.hksname=yyxsname;
	}
}

public class hk8 {
	public static void main(String[] args) {
	    hkStu stu[]=new hkStu[2];
		stu[0]=new hkStu(10001,"张三");
		stu[1]=new hkStu(10002,"李世");
		
		System.out.println("yyxid="+stu[0].hkid+",yyxsname="+stu[0].hksname);
		System.out.println("yyxid="+stu[1].hkid+",yyxsname="+stu[1].hksname);
	}
}

结果
在这里插入图片描述

请你吃颗糖吧

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
简单Java程序2

数组（1）public class hk1 { public static void main(String[] args) { int hka[]= {1,3,5}; int hka2[]=new int[] {2,4,6}; int hka3[]=new int[3] ;//没有指明长度，将会创建3个可以存放int变量的内存空间，初始值为0 System.out.prin...
复制链接

扫一扫