JAVA基础(4)

最新推荐文章于 2022-02-28 17:57:41 发布

ss_zz

最新推荐文章于 2022-02-28 17:57:41 发布

阅读量205

点赞数

分类专栏： JAVA

本文链接：https://blog.csdn.net/ss_zz/article/details/90597171

版权

JAVA 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

这篇博客介绍了Java中的Random类的使用，包括如何导入、创建对象和生成随机数。接着讲解了数组的概念、定义、初始化以及常见的异常处理。文章还探讨了Java内存分配，特别是栈和堆的区别，并提及了方法的封装和调用。最后，博客讨论了冒泡排序的方法和应用场景。

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

Random使用方法

Random使用方法和Scanner类似

1、导报

import iava.util.R

2、创建对象

Random r = new Random ();

3、获取随机数

int num = r.nextInt(100);

产生的数是0~100的，包括0，不包括100
括号中的100是可以变化的，控制随机数产生的范围

代码应用
```
Random r = new Random();
int number = r.nextInt(100);
```

数组

1、数组的概念：数组是存贮同一种数据类型多个变量的容器，数组既可以存储基本数据类型，也可以存储引用数据类型

2、数组的定义格式：

格式1:数据类型[] 数组名；

格式2:数据类型数组名[]（java中不建议时用这种方法）

int[] arr = new int[5];//第一种声明格式
int arr1[] = new int[5];//第二种声明格式

3、数组的初始化：必须先初始化，在使用

初始化：数组中的数组元素进行分配内存空间，并且为每一个数据元素进行赋值

初始化两种方法：

1）、动态初始化：初始化时，只指定数组长度，由系统来为数组分配初始值。

2）、静态初始化：初始化时，指定每一个数组元素的初始化值，由系统来决定数组的长度。

int[] arr2 = new int[4];//动态初始化，又初始化值，默认值为0
int[] arr3 = new int[] {1,3,5,7};//静态初始化
int[] arr4 = {1,3,5,7};//静态简化版

4、数组的异常

1）、数组越界异常

访问了数组中不存在的索引

ArrayIndexOutOfBoundsException

int[] arr5 = new int[] {1,2,3,4};
System.out.println(arr5[5]);

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 5
	at CodeDemo04.ArrayDemo.main(ArrayDemo.java:25)

2）空指针异常

	NullPointerException

数组中的引用没有指向对象，但是却在操作对象中的元素

int[] arr = {1,2,3};
arr = null;
System.out.println(arr[2]);

Exception in thread "main" java.lang.NullPointerException
	at CodeDemo04.ArrayAbnormalDemo.main(ArrayAbnormalDemo.java:12)

3)数组下标越界异常

java.lang.ArrayIndexOutOfBoundsException: 3
	at CodeDemo04.ArrayAbnormalDemo.main(ArrayAbnormalDemo.java:14)

5、异常的处理（try catch）

try {
		int[] arr1 = {1,2,3};
		arr = null;
		System.out.println(arr1[3]);
	} catch (ArrayIndexOutOfBoundsException e) {
		System.out.println("发生数组下标越界异常");
		e.printStackTrace();
		// TODO: handle exception
	}

发生数组下标越界异常
java.lang.ArrayIndexOutOfBoundsException: 3
	at CodeDemo04.ArrayAbnormalDemo.main(ArrayAbnormalDemo.java:18)

5、数组的访问

通过（数组名.leng）来获取数组的长度（元素个数）

int[] arr = new int[5];
for (int i = 0; i < arr.length; i++) {
			System.out.println(arr[i]);
		}

arr5 = new int[] {1,2,3,4};
System.out.println(arr5);//访问的是数组的地址

java 中的内存分配：

栈：

存储的是局部变量
局部变量就是定义在方法体中的变量
使用完毕之后就会被释放，立即收回

堆：

		存储的是new出来的对象：实体；
		 每一个对象都是有地址的；
		每一个对象的数值都是有默认值的

byte , short, ,long------0 ;

float, double-------0.0 ;

char------------------’\u0000’ ;

boolean-------------false ;

引用类型-----------null ；

使用完毕后，会在垃圾回收器空闲的时候，被回收。
方法区：
本地方法区：（和系统有关系）
寄存器：（给cpu使用的）

代码应用（身份证号的检验）

package CodeDemo04;

import java.util.Scanner;

import org.omg.IOP.Codec;

public class Card001Demo {
	public static void main(String[] args) {
		//存放用户身份证号
		int[] cards = new int[17];
		//定义系数
		int[] coef = new int[] {7 , 9 , 10 , 5 , 8 , 4 , 2 , 1 , 6 , 3 , 7 , 9 , 10 , 5 , 8 , 4 , 2};  
		//定义余数
		char[] rem = new char[] {'1' , '0' , 'X' , '9' , '8' , '7' , '6' , '5' , '4' , '3' , '2'};
		int sum  = 0;
		Scanner sc = new Scanner(System.in);
		for (int i = 0; i < cards.length; i++) {
			System.err.println("请输入你的身份证第"+i+"位：");
			cards[i] = sc.nextInt();
		}	
		for (int i = 0; i < cards.length; i++) {
			sum += cards[i] * coef[i];
		}	
		System.out.println("最后一位" + rem[sum % 11]);
	}
}

6、数组的复制

package CodeDemo04;
//数组的复制
import java.util.Arrays;

public class ArrayExtendDemo {
	public static void main(String[] args) {
		char[] arr = {'北','京'};
		char[] arr2 = Arrays.copyOf(arr,4);
		char[] arr3 = arr2;
		arr3[2] = '达';
		arr3[3] = '内';
		System.out.println(arr3);				
	}
}

break 和 continue 的区别

代码应用

package CodeDemo04;
/**
 * 1、for:固定次数循环
 * 2、break:tiaochuxunhuan
 *   continue:跳过循环体中的剩余语句进入下一轮循环
 * 3、嵌套循环
 * 1）嵌套中的循环，一般多行多列时，外层控制行，内层控制列
 * 2）执行规则：外层循环走一次，内层走所有次
 * 3）循环层数越少越好，能用一层解决，不要用多层，如果写的程序使用到了三层以上循环，就应考虑程序设计是否有问题
 * 4）break只能跳出一层循环，
 * 4、
 * 5、
 * 
 * @author Administrator
 *
 */

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

		for (int j = 0; j < 10; j++) {
			if (j % 2 == 0) {
				continue;				
			}
			System.out.println(j);
		
/*		int a = 0;
		
		for (int j = 0; j < 5; j++) {
			if (j == 2) {
				break;				
			}
			System.out.println(j);
*/
		}
	}
}

冒泡排序

代码应用

package CodeDemo04;

public class PackageDemo {
	
	public static void bubbleSorted(int[] arr){
		boolean isSorted;
		for (int i =0;i<arr.length-1;i++){//轮数
			isSorted = true;//假设剩下的元素已经排序好了
			for (int j =0;j<arr.length - 1 -i;j++){//每次都和下一个元素进行比较
				if(arr[j]>arr[j+1]){
					int temp = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = temp;
					isSorted = false;
					//一旦需要交换数组元素，说明剩下的元素没有排序好
				}
			}
			for(int j = 0; j < arr.length; j++){
				System.out.println(arr[j]);
			}
			System.out.println("排序的趟数：" + i);
			if(isSorted){
				break;//如果没有发生交换，说明剩下的元素已经排序完毕。
			}
		}
		System.out.println("排序后数组：");
		for(int i = 0; i < arr.length; i++){
			System.out.println(arr[i]);
		}
	}
}

调用冒泡排序

package CodeDemo04;

public class TransferDemo{
	public static void main(String[] args) {
		int [] arr={1,4,2,3};
		PackageDemo s = new PackageDemo();
		s.bubbleSorted(arr);
	}
}

方法（函数，过程）

1、封装了一段特定业务逻辑的功能

方法尽可能是独立的，让一个方法去干一件事

方法是可以被反复和重复调用的

减少代码的重复，有利于代码的后期维护同时能减少团队开发成本，提高开发效率

2、语法结构

修饰词返回值类型方法名（参数类型参数名1，参数类型参数名2，…）{

方法体： //具体的业务逻辑功能
return 返回值（如果无返回值类型，就没有return返回值；）

}

修饰词：public static（目前使用）

返回值类型：用于限定返回值的具体类型，

方法名：为了调用时方便而起的名字

参数列表：（数据类型参数名，数据类型参数名2…）

参数类型：同用于限定调用方法时传入的数据类型

参数名：用于接收调用方法是时传入的数据的变量

方法体：业务逻辑功能的具体实现

return：结束方法，把返回值传给调用者

3、方法的使用
1）明确方法是否有返回值
2）方法是否有参数列表
4、方法的调用
1）单独去调用，一般不建议
2）输出调用，有意义,不太完善
3）复制调用，推荐使用

方法：

有参数有返回值类型

public static  int sum(int x, int y ) {
		return x + y;
	}

有参数无返回值类型

public static  double getSalary(){
		//return;//编译错误 ,必须返回一个值
		//return "123";//编译错误返回值类型必须进行			
		return 30000.0;

无参数有返回值类型

public static void sayHi(String name,String address){
		System.out.println("大家好，我叫"+name+",家住"+address);
	}

无参数无返回值类型

public static void sayHi(){
		System.out.println("大家好我叫小郭");
}

ss_zz

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录