Java笔记3

发表于 阅读次数：

控制结构

  1. 选择结构
    1.1条件分支（if与if-else语句）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Test {

	public static void main(String[] args) {
		int num = 1;
		if(num==1) {
			System.out.println("Right1");
		}
		System.out.println("go on!");
		if(num==2) {
			System.out.println("Right2");
		}
	}
}
#Right1

1.2 if-else语句
基本部分： if（true）

{

执行这里

} else

{

执行这里（条件为假）

}

1
2
3
4
5
6
7
8
public static void main(String[] args) {
		int num = 1;
		if(num==1) {
			System.out.println("1");
		}else {
			System.out.println("2");
		}
	}

1.3多条件的if-else
if(判断条件1)

{

——-语句块1；

}else if(判断条件2)

{

——–语句块2

}else

{

——–语句块3

}

1.4多重选择—switch语句

switch(表达式)

{

case 值1:语句块1;break;

case 值2:语句块2;break;

…

default:语句块n；break;

}

二、循环结构

2.1 while循环（当型循环）

while(判断条件)

{

——代码块

}

1
2
3
4
5
6
7
8
9
10
11
12
13
    2.2 do-while循环
	2.3 for循环
	2.4 foreach循环：用来循环遍历一个数组或集合框架
	for（类型 迭代类型:数组或集合）{
					代码块
	}
实现数组的遍历:
public static void main(String[] args) {
		int arr[] = {1,2,3,4,5};
		for(int item:arr) {
			System.out.println(item);
		}
}

2.5 嵌套循环
三、循环的跳转

break;continue;return;

3.1 break ：跳出所在的循环（switch、for、while）

1
2
3
4
5
6
7
8
public static void main(String[] args) {
		int i;
		for(i=1;i<10;i++)
		{
			if(i%3==0) break;
			System.out.println(i);
		}
	}

3.2 contiue:结束本次循环进入下一次循环

1
2
3
4
5
6
7
8
public static void main(String[] args) {
		int i;
		for(i=1;i<11;i++)
		{
			if(i%3==0) continue;
			System.out.println(i);	
		}
	}

3.3 return:离开语句所在的方法

1
2
3
4
5
6
7
8
public static void main(String[] args) {
		int i;
		for(i=1;i<11;i++)
		{
			if(i%3==0) return;
			System.out.println(i);	
		}
	}

小知识：
三目运算符也就是if-else的简写形式，Switch中不是每个条件都需要break

数组（与C大致一同，但有不同）

一、一维数组

定义：类型[ ] 数组名 = new 类型[长度]；

数组中存有默认值0，而在引用类型[ ]中为null;

如果在定义前，已经知道数组里存放的内容，那可以简单定义为：

类型[ ] 数组名 = {值1，值2，…，值n}；

类型[ ] 数组名 = new 类型[ ]{值1，值2，…，值n}；

动态初始化如：int[ ] array = new int[4];

静态初始化如：int[] array = new int[]{1,2,3,4};

但是像int[] array = new int[3]{1，2，3};就是错误的写法

这样也是错的，int[ ] array；array[ ] = {1,2,3};也是错的！！！

而这样是可以的：把String names[ ] = new String[ ]{“加油”，“冲呀”}；

拆为：String names[ ] ；和 names[ ] = new String[ ]{“加油”，“冲呀”}；

创建一个随机数组:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import java.util.Random;    //导入包

public class Test {
	public static void main(String[] args) {
		Random rand = new Random();
		int[] a = null;
		a = new int[rand.nextInt(10)]; //开辟内存空间，长度是[0，10）的随机数
		System.out.println("数组的长度："+a.length);
		for(int i=0;i<a.length;i++) {
			a[i] = rand.nextInt(100);
			System.out.println("a["+i+"]="+a[i]);
		}
	}
}

引用传值举例(两个数组对应同一个内存)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
public class Test{
	public static void main(String[] args) {
			int[] nums1 = {1,2};
			int[] nums2 = nums1;  //这里其实把nums1中记录的数组的地址传给了nums2
			//现在遍历两个数组
			System.out.println("第一个数组");
			for(int x:nums1) {
				System.out.println(x);
			}
			System.out.println("第二个数组");
			for(int y:nums2) {
				System.out.println(y);
			}
			//现在 修改下第二个数组中元素值
			nums2[1] = 100;
			System.out.println("第一个数组");
			for(int x:nums1) {
				System.out.println(x);
			}
			System.out.println("第二个数组");
			for(int y:nums2) {
				System.out.println(y);
			}
	}
}
输出结果为：
第一个数组
1
2
第二个数组
1
2
第一个数组
1
100
第二个数组
1
100

简单的比较最大值和最小值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class Test {
	public static void main(String[] args) {
			int nums[] = {100,5};
			int max = nums[0];
			int min = nums[0];
			for(int i=1;i<nums.length;i++) {
				if(nums[i]>max) {
					max = nums[i];
				}
			}
			for(int i=1;i<nums.length;i++) {
				if(nums[i]<min) {
					min = nums[i];
				}
			}
			System.out.printf("该数组中最大值为：%d，最小值为：%d",max,min);
	}
}

二、二维数组
定义：数据类型[ ][ ] 数组名 = new int[行数][列数];

如：int[ ][ ] array = new int [3][2];或者int[ ][ ] array; array = new int[3][2];

我这里将这个理解为线代里的行列式或者矩阵

1
2
3
4
5
6
7
8
9
10
11
public class Test {
    public static void main(String[] args) {
		int[][] nums;
		nums = new int[3][2];
		for(int i=0;i<nums.length;i++) {
			for(int j=0;j<nums[i].length;j++) {
				System.out.println("nums["+i+"]["+j+"]="+nums[i][j]);
			}
		}
	}
}

再举例列数不定

1
2
3
4
5
6
7
8
9
10
11
12
13
public class Test {
	public static void main(String[] args) {
		int[][] nums = new int[3][];
		nums[0] = new int[2];
		nums[1] = new int[2];
		nums[2] = new int[] {1,2};
		for(int i=0;i<nums.length;i++) {
			for(int j=0;j<nums[i].length;j++) {
				System.out.println("nums["+i+"]["+j+"]="+nums[i][j]);
			}
		}
	}
}

如果知道数组中存的值还可以：

1
2
3
4
5
6
7
8
9
10
11
public class Test {
	public static void main(String[] args) {
		int[][] nums = {{1,2},{1,2,3},{2}};
		for(int i=0;i<nums.length;i++) {
			for(int j=0;j<nums[i].length;j++) {
				System.out.println("nums["+i+"]["+j+"]="+nums[i][j]);
			}
		}
	}

}

sample计算工资总额

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class Test {

	public static void main(String[] args) {
		int sum = 0;
		int[][] nums = {{1,2},{1,2,3},{2}};
		for(int i=0;i<nums.length;i++) {
			System.out.printf("第%d个人的销售总额为：",(i+1));
			for(int j=0;j<nums[i].length;j++) {
				sum += nums[i][j];
			}
			System.out.println(sum);
			sum = 0;   //清零便于下一次计算
		}
	}

}

三、多维数组
定义：数据类型[ ][ ]…[] 数组名 = new int[ ][ ]…[]

另外在Java中null可以为引用类型赋值，作为初始值

1
2
3
4
5
6
public static void main(String[] args) {
		String name = null;
		name = "冲冲冲";
		System.out.println(name);
		
	}

如果想要比较两个字符串，用equals()来进行比较，返回一个布尔值，如果报错信息是NullPointerException可以考虑是空对象
随机数(乱序）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
import java.util.Random;
public class Test {

	public static void main(String[] args) {
		Random random = new Random();
		int buf;
		int[] nums = new int[random.nextInt(10)];
		for(int i=0;i<nums.length;i++) {
			nums[i] = random.nextInt(100);	
		}
		for(int i=0;i<nums.length-1 ;i++) {
			for(int j=0;j<nums.length-i-1;j++) {
				if(random.nextBoolean()) {
					buf = nums[j];
					nums[j] = nums[j+1];
					nums[j+1] = buf;
				}
			}
		}
		for(int x:nums) {
			System.out.println(x);
		}
}

}

方法：

1.方法的定义

修饰符 返回值类型 方法名（参数列表）{

方法体

[return 返回值]

}

两数比较大小的例子

1
2
3
4
5
6
7
8
9
10
11
public class Test {
	public static int max(int num1,int num2) {
		int result;
		if(num1>num2) {
			result = num1;
		}else {
			result = num2;
		}
		return result;
	}
}

2、方法的使用
Add:this代表本类对象

哪个对象调用这个方法this就是它；

比如Person p1 = new Person(); 此时this代表p1；

如果修饰符没有写，就默认为default

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class Person {
	String name;
	int age;
	void talk() {
		System.out.println("冲冲冲！！！");
		System.out.println("我是"+name+"今年"+age+"岁");
	}
	//当局部变量与成员变量重名的时候用this区分 
	void setName(String name){
		this.name = name;//将局部变量赋值给成员变量
	}
	void setAge(int age) {
		this.age = age;
	}
}

Person1test.java

1
2
3
4
5
6
7
8
9
10
public class Person1Test {

	public static void main(String[] args) {
		Person p1 = new Person();
		p1.setName("1");    //调用方法
		p1.setAge(32);
		p1.talk();
	}

}

3、方法中的形参与实参
形参：隶属于方法体，是方法的局部变量

在调用方法时，实参和形参在数量、类型、顺序上必须保持一致；

4、方法的重载

三要素：必须在同一个类；必须方法名相同；必须参数列表不同（个数与类型）

注意：重载定义与返回值无关

1
2
3
4
5
6
7
8
9
10
11
public class Test {
	public int add(int a,int b) {
		return a+b;
	}
	public int add(int a,int b,int c) {
		return a+b+c;
	}
	public float add(float a,float b) {
		return a+b;
	}
}

5、构造方法
构造方法就是每一个类中定义的，并且是再使用new关键字实例化一个新对象的时候默认调用的方法。

构造方法的功能是对新创建对象的成员变量赋值

语法结构：访问修饰符 类名（[参数列表]）{

功能代码

}

注意：

1、构造方法的名字必须与所属类类名一致

2、构造方法无返回值，也不可以使用void

3、构造方法可以被重载

4、构造方法不能被static和final修饰

5、构造方法不能被继承，子类使用父类的构造方法需要使用super关键字

规定：如果某一个类中，没有显式的定义一个构造方法，那系统会默认给其一个无参的构造方法，并且方法体式空的构造方法；

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class Person {
	int age;
	String name;
	public Person(int age) {
		this.age = age;
		System.out.println("构造方法Person(int x)被调用");
		System.out.println("age="+this.age);
	}
	public Person() {
		System.out.println("构造方法Person()被调用");
	}
	public Person(String name,int age) {
		System.out.println("构造方法Person(String name,int age)被调用");
		this.age = age;
		this.name = name;
	}
	public void talk() {
		System.out.println("name="+name+"age="+age);
	}
}

构造方法也可用于私有化，不过只能在当前类，一般用于单例
6、在方法中调用方法

1、 如果调用本类的方法,直接使用方法名（[实际]）

2、如果调用的是其他类的方法，还是需要创建对象，然后通过对象名.方法（[实参]）的形式调用 ；

3、如果调用的方法是静态的，可以通过类名.方法名（[实参]）或接口名.方法名([实参]);

快捷键：Alt+Shift+s 封装Getters和Setters；

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public class Person {
	private String name;
	private int age;
	
	private void talk() {
		System.out.println("我是"+name+",今年："+age+"岁");
	}
	private void say() {
		talk();
		//this.talk();
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
}

7、方法的递归调用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class Test {
	public int add(int n){
		int result = 0;
		for(int i=1;i<n+1;i++) {
			result += i;
		}
		return result;
	}
	
	public int addRecursion(int n) {
		if(n==1) {
			return n;
		}else {
			return n+addRecursion(n-1);
		}
	}
	
}

8、代码块
格式：{ 语句}

分为四种；

1、普通代码块；

2、构造代码块；

3、静态代码块；

4、同步代码块；

//普通代码块：方法名后或方法体内用一对“{}”括起来的数据库；

1
2
3
4
5
6
7
8
9
10
public class Test {
	public static void main(String[] args) {
		{
			int x = 10;
			System.out.println("普通代码块内，x="+x);
		}
		int x = 100;
		System.out.println("x="+x);
	}
}

//构造代码块

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public class Test {
	private String name;
	private int x;
	//构造代码块  
	{
		System.out.println("构造代码块");
		x= 100;
		show();
	}
	//无参构造方法
	GzCodeBlock2(){
		System.out.println("构造");
		name = "张三";
	}
	//有参构造方法
	GzCodeBlock2(String name){
		System.out.println("hh");
		this.name = name;
		show();
	}
	void show() {
		System.out.println("welcome"+name);
		System.out.println("x="+x);
	}
}

//静态代码块
加一个static即可；执行一次；

9、方法和数组

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
public class Test {

	public static void main(String[] args) {
		int in = 10;
		int[] arr = new int[]{1,2,3,4,5};
		System.out.println("---调用changeReferVAlue前---");
		printArr(arr);
		changeReferValue(in, arr);
		System.out.println("---调用changeReferVAlue后---");
		print(in, arr);
	}
	public static void changeReferValue(int a,int[] myArr) {
		a+=1;
		for(int i=0;i<3;i++) {
			myArr[i] = 0;
		}
	}
	public static void printArr(int[] arr) {
		for(int i:arr) {
			System.out.print(i+"\t");
		}
		System.out.println("");
	}
	public static void print(int in,int[] arr) {
		System.out.println("in:"+in);
		System.out.println("arr:");
		printArr(arr);
	}

}

返回数组的方式：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
public class ArrayReturn {
	public static int[] sort(int[] arr) {
		for(int i = 0;i<arr.length-1;i++) {
			for (int j = 0; j < arr.length-i-1; j++) {
				if(arr[j]>arr[j+1]) {
					int temp =arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = temp;
				}
			}
		}
		return arr;
	}
	public static void printArr(int[] arr,String msg) {
		System.out.println(msg);
		for(int i:arr) {
			System.out.print(i+"\t");
		}
		System.out.println("");
	}
	public static void main(String[] args) {
		int[] arr = {3,5,2,6,8,4,7,9};
		int arrNew[];
		printArr(arr,"排序前");
		arrNew = sort(arr);
		printArr(arrNewa, "排序后");
	}
}

10、与数组有关的操作方法
1、数组的克隆

克隆对象返回的是一个新的对象，而不是已有对象的引用

克隆对象与new操作符是有区别的，克隆对象是拷贝某个对象的当前信息，而不是对象的初始化信息；

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class ArrraytMethod {
	public static void printArr(int[] arr) {
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i]+"\t");
		}
		System.out.println("");
	}
	//克隆内容相同，地址不同
	public static void main(String[] args) {
		int[] arr= {3,5,7,3,7,89,54,3,2,65,7};
		printArr(arr);
		System.out.println(arr);
		int[] arrNew = arr.clone();
		printArr(arrNew);
		System.out.println(arrNew);
	}
}

2、利用系统类库排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import java.util.Arrays;

public class ArrraytMethod2 {
	public static void printArr(int[] arr) {
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i]+"\t");
		}
		System.out.println("");
	}
	//使用Arrays的sort方法，默认从小到大排序
	public static void main(String[] args) {
		int[] arr= {3,5,7,3,7,89,54,3,2,65,7};
		System.out.println("排序前");
		printArr(arr);
		Arrays.sort(arr);
		System.out.println("排序后");
		printArr(arr);
	}
}

数组中去除指定数字

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
public class Test {
	public static void main(String[] args) {
		int[] oldArr = {1,3,4,5,0,0,6,6,0,5,4,7,6,7,0,5};
		int count = getValueNumFromArray(oldArr, 0);
		int[] newArr = new int[oldArr.length-count];
		copyValue(oldArr, newArr);
		printArray(newArr);
	}
	public static int getValueNumFromArray(int[] arr,int val) {
		int count = 0;
		for (int i = 0; i < arr.length; i++) {
			if(arr[i]==val) {
				count++;
			}
		}
		return count;
	}
	public static void copyValue(int[] arr1,int[] arr2) {
		int j = 0;
		for (int i = 0; i < arr1.length; i++) {
			if(arr1[i]!=0) {
				arr2[j] = arr1[i];
				j++;
			}
		}
	}
	
	public static void printArray(int[] array){
		for (int i = 0; i < array.length; i++) {
			System.out.println(array[i]+"\t");
		}
		System.out.println("");
	}
	
}

两个数之间的随机数

1
2
3
4
5
6
7
8
9
10
11
12
13
public class Test{
	public static void main(String[] args) {
		int num1 = 1;
		int num2 = 16;
		for(int i=0;i<100;i++) {
			System.out.println(getRandom(num1, num2));
		}
	}
	public static int getRandom(int num1,int num2) {
		int result = (int)Math.random()*(num2-num1)+num1;
		return result;
	}
}