JAVA学习：基础入门（下）

系统管理员 2022-12-16 09:24 140阅读 0赞

### 文章目录 ###

*  7、 for循环
 *  8、while循环
 *  9、函数入门
 *  10、函数的形参和实参
 *  11、continue跳出本次循环
 *  12、使用break跳出循环
 *  13、基本类型的数组
 *  14、类与对象
 *  15、引用类型的数组
 *  16、else if 条件分支

# 7、 for循环 #

变量包括：局部变量、成员变量、静态变量  
局部变量：定义在方法内的变量。作用域：变量所在的\{\}，超过\{\}变量就找不到了。

例：求和1到100

public class Test {
        
    
    	public static void main(String[] args) {
        
    	
    		//编写1~100求和
    		int sum = 0;
    		for (int i=0;i<=100;i++) {
        			
    			sum += i;
    		}		
    		System.out.println("求和：" + sum);
    	}
    }
    //Results:
    求和：5050

# 8、while循环 #

public class Test {
        
    
    	public static void main(String[] args) {
        
    		
    		int k = 0;
    		int sum = 0;
    		while(k<100) {
        
    			k++;
    			sum += k;
    		}
    		System.out.println("sum=" + sum);
    	}
    }
    //Results
    sum=5050

# 9、函数入门 #

**函数（方法、行为）**：  
**注意：函数命名，要用动词开头，首字母要小写。**  
void：表示返回值为空。  
分别抽取上述例子中的`for`循环和`while`循环：

public class Test {
        
    
    	public int qiuhe() {
        
    		//编写1~100求和
    		int sum = 0;
    		for(int i=0;i<=100;i++) {
        
    			sum += i;
    		}
    		return sum;
    	}
    	
    	public static void main(String[] args) {
        
    		Test t = new Test();
    		int a = t.qiuhe();
    		System.out.println("求和结果：" + a);
    	}
    }
    //求和结果：5050

public class Test {
        
    
    	public int qiuhe2() {
        
    		//编写1~100求和
    		int k = 0;
    		int sum = 0;
    		while(k<100) {
        
    			k++;
    			sum += k;
    		}
    		return sum;
    	}
    	
    	public static void main(String[] args) {
        
    		Test t = new Test();
    		int a = t.qiuhe2();
    		System.out.println("求和结果：" + a);
    	}
    }
    //求和结果：5050

# 10、函数的形参和实参 #

m和n是两个int类型的变量，他们都被成为形参。具体调用时，传入的具体数值被称为实参。

public class Test {
        
    
    	public int qiuhe(int m, int n) {
        
    		//编写m到n的求和
    		int sum = 0;
    		for(int i=m; i<=n; i++ ) {
        
    			sum += i;
    		}
    		return sum;
    	}
    	
    	public static void main(String[] args) {
        
    		Test t = new Test();
    		int s = t.qiuhe(3, 100);
    		System.out.println("结果：" + s);
    	}
    }

p和q与此前例子中的m和n同理。

public class Test {
        	
    	
    	public int qiuhe2(int p, int q) {
        
    		int sum = 0;
    		while(p<=q) {
        
    			sum += p;
    			p++;
    		}
    		return sum;
    	}
    	
    	public static void main(String[] args) {
        
    		Test t = new Test();
    		int s = t.qiuhe2(3, 100);
    		System.out.println("结果：" + s);
    	}
    }

# 11、continue跳出本次循环 #

`continue`意为跳出本次循环，后面的代码不再执行。

public class Test {
        
    
    	public int qiuhe(int m, int n) {
        
    		
    		int sum = 0;
    		for(int i=m; i<=n; i++ ) {
        
    			if(i%5 == 0) {
        
    				continue;
    			}
    			sum += m;
    			m++;
    		}
    		return sum;
    	}
    	
    	
    	public static void main(String[] args) {
        
    		Test t = new Test();
    		int s = t.qiuhe(1, 100);
    		System.out.println("结果：" + s);
    	}
    }
    //结果：3240

# 12、使用break跳出循环 #

public class Test {
        
    
    	public int qiuhe(int m, int n) {
        
    		
    		int sum = 0;
    		for(int i=m; i<=n; i++ ) {
        
    			if(i%5 == 0) {
        
    				break;
    			}
    			sum += m;
    			m++;
    		}
    		return sum;
    	}
    	
    	
    	public static void main(String[] args) {
        
    		Test t = new Test();
    		int s = t.qiuhe(1, 100);
    		System.out.println("结果：" + s);
    	}
    }
    //结果：10

# 13、基本类型的数组 #

public class Test {
        
    	
    	public static void main(String[] args) {
        
    		int[] aSZ = {
        10,20,30,40};
    		
    		for(int i=0;i<aSZ.length;i++){
        
    			int a = aSZ[i];
    			System.out.println("a=" + a);
    		}
    	}
    }
    //
    a=10
    a=20
    a=30
    a=40

我们也可以采用断点的方式来看这个数组，右键选择Debug as进入，可以看到：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzQyNTc0MDY5_size_16_color_FFFFFF_t_70_pic_center]

> **断点调试：  
> 1、F6 单步调试  
> 2、F8 跳到下一个断点**

第二种数组的写法：

public class Test {
        
    	
    	public static void main(String[] args) {
        
    		int[] bSZ = new int[10];
    		bSZ[0] = 1;
    		bSZ[1] = 2;
    		bSZ[2] = 3;
    		bSZ[3] = 4;
    		bSZ[4] = 5;
    		for(int i=0;i<bSZ.length;i++) {
        
    			int b = bSZ[i];
    			System.out.println("b=" + b);
    		}
    	}
    }
    //result
    b=1
    b=2
    b=3
    b=4
    b=5
    b=0
    b=0
    b=0
    b=0
    b=0

因为数组中其他的变量没有赋值，因此后面全部显示为0。

# 14、类与对象 #

> 类：类型（名词）  
> 抽象：从一群特殊的个体中，提取他们共有的特征，是从特殊到一般的过程。  
> 对象：具有类特性的特殊个体。创建对象是从一般到特殊的过程。  
> 类的抽取过程：1、提取名词；2、提取属性信息；3、提取行为信息

**做一个小狗类的例子：**

*  第一步，创建一个biz（biz：业务逻辑的缩写）
 *  第二步，创建`Dog`类。  
    ![在这里插入图片描述][20201024170712114.png_pic_center]  
    代码如下（包含小狗的名字、颜色和年龄）：

package com.icss.bk.biz;
    
    public class Dog {
        
    	public String name;
    	public String color;
    	public double age;
    }

*  第三步，在ui包下创建`TestDog`类：  
    ![在这里插入图片描述][20201024171132944.png_pic_center]  
    输入代码：

public class TestDog {
        
    
    	public static void main(String[] args) {
        
    		Dog d1 = new Dog();
    		
    	}
    }

然后会出现错误：  
![在这里插入图片描述][20201024171255834.png_pic_center]  
出现错误是由于没有导包。按Ctrl+Shift+o 可以进行快速导包。导完之后代码变为如下：

package com.icss.ui;
    
    import com.icss.bk.biz.Dog;
    
    public class TestDog {
        
    
    	public static void main(String[] args) {
        
    		Dog d1 = new Dog();
    		
    	}
    }

*  第四步继续为小狗的名字、颜色和年龄赋值，并打印输出：

import com.icss.bk.biz.Dog;
    
    public class TestDog {
        
    
    	public static void main(String[] args) {
        
    		Dog d1 = new Dog();
    		d1.name = "Muse";
    		d1.color = "Black";
    		d1.age = 1.5;
    		
    		System.out.println(d1.name + "---" + d1.color );
    		
    	}
    }
    //result
    Muse---Black

这就是一个对象。  
根据一个类，我们可以创建多个对象。

package com.icss.ui;
    
    import com.icss.bk.biz.Dog;
    
    public class TestDog {
        
    
    	public static void main(String[] args) {
        
    		Dog d1 = new Dog();
    		d1.name = "Muse";
    		d1.color = "Black";
    		d1.age = 1.5;
    		System.out.println(d1.name + "---" + d1.color );
    		
    		Dog d2 = new Dog();
    		d2.name = "Angela";
    		d2.color = "White";
    		d2.age = 2;
    		System.out.println(d2.name + "---" + d2.color );
    		
    	}
    }
    //result
    Muse---Black
    Angela---White

# 15、引用类型的数组 #

之前，我们做了基本类型的数组，并进行了遍历。现在我们做一个引用类型的数组，并进行遍历。

运行后，我们得到的结果如下图：  
![在这里插入图片描述][20201024185050858.png_pic_center]  
虽然我们得到了结果，但是出现了空指针异常，因为`Dog`数组中有10个，但在实际写的时候只写了3个，因此需要做一个判断：

package com.icss.ui;
    
    import com.icss.bk.biz.Dog;
    
    public class TestDog {
        
    	
    	public static void testDogSZ() {
        
    	
    		Dog d1 = new Dog();
    		d1.name = "Muse";
    		d1.color = "Black";
    		d1.age = 1.5;
    		
    		Dog d2 = new Dog();
    		d2.name = "Angela";
    		d2.color = "White";
    		d2.age = 2;
    		
    		Dog d3 = new Dog();
    		d3.name = "Carrey";
    		d3.color = "Yellow";
    		d3.age = 3;
    		
    		Dog[] dogs = new Dog[10];    //给定义的dogs类型赋一块内存空间
    		dogs[0] = d1;
    		dogs[1] = d2;
    		dogs[2] = d3;
    		
    		for (int i=0;i<dogs.length;i++) {
        
    			Dog dog = dogs[i];
    			if(dog != null) {
        
    				System.out.println(dog.name + "---" + dog.color );
    			}
    			
    		}
    	}
    
    	public static void main(String[] args) {
        
    		TestDog.testDogSZ();
    		
    	}
    }
    //result
    Muse---Black
    Angela---White
    Carrey---Yellow

改变了代码之后，运行就正常了。

# 16、else if 条件分支 #

下面我们把不同颜色的小狗进行分类：

import com.icss.bk.biz.Dog;
    
    public class TestDog {
        
    	
    	public static void testDogSZ() {
        
    	
    		Dog d1 = new Dog();
    		d1.name = "Muse";
    		d1.color = "Black";
    		d1.age = 1.5;
    		
    		Dog d2 = new Dog();
    		d2.name = "Angela";
    		d2.color = "White";
    		d2.age = 2;
    		
    		Dog d3 = new Dog();
    		d3.name = "Carrey";
    		d3.color = "Yellow";
    		d3.age = 3;
    		
    		Dog[] dogs = new Dog[10];    //给定义的dogs类型赋一块内存空间
    		dogs[0] = d1;
    		dogs[1] = d2;
    		dogs[2] = d3;
    		
    		int sumYellow = 0;
    		int sumBlack = 0;
    		int sumWhite =0;
    		int sumOther = 0;
    		
    		for (int i=0;i<dogs.length;i++) {
        
    			Dog dog = dogs[i];
    			if(dog != null) {
        
    				if(dog.color.equals("Yellow")) {
         //.equals用于比较字符串的内容
    					sumYellow += 1;
    				}else if(dog.color.equals("Black")) {
        
    					sumBlack +=1;
    				}else if(dog.color.equals("White")) {
        
    					sumBlack +=1;}
    				else {
        
    					sumOther +=1;
    				}		
    			}	
    		}
    		System.out.println("Sum of Yellow:" + sumYellow);
    		System.out.println("Sum of Black:" + sumBlack);
    		System.out.println("Sum of White:" + sumWhite);
    		System.out.println("Sum of Other:" + sumOther);
    	}
    
    	public static void main(String[] args) {
        
    		TestDog.testDogSZ();
    		
    	}
    }
    
    //
    Sum of Yellow:1
    Sum of Black:2
    Sum of White:0
    Sum of Other:0

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzQyNTc0MDY5_size_16_color_FFFFFF_t_70_pic_center]: /images/20221123/3a2f7af7b5af4adeab905fec31c1a24f.png
[20201024170712114.png_pic_center]: /images/20221123/eaca1d2bc3f1410197d34c9577d2b49d.png
[20201024171132944.png_pic_center]: /images/20221123/9456c9e9163b490a8deac8def7048c19.png
[20201024171255834.png_pic_center]: /images/20221123/0d469e291bed4f76a739e5da305522e0.png
[20201024185050858.png_pic_center]: /images/20221123/2f29c39dae974d96826c950fe261d16a.png