①java自学笔记——java基本语法

最新推荐文章于 2023-03-04 15:11:07 发布

原创最新推荐文章于 2023-03-04 15:11:07 发布 · 539 阅读

3 ·

本内容遵循CC 4.0 BY-SA版权协议

收录于

java学习笔记

本文深入讲解Java语言的基础语法，包括语言组成、数据类型、运算符、数组、控制语句等核心概念，通过丰富的实例帮助读者理解和掌握Java编程的基本技巧。

java基本语法

一、java语言组成

1.分隔符

空白符、注释、普通分隔符

2.关键字

在这里插入图片描述

3.标识符

在这里插入图片描述

二、数据类型

1.基本数据类型

在这里插入图片描述

（一）布尔类型

在这里插入图片描述

（二）字符类型

字符型 char 单个字符
逃逸字符（转义字符）：例如"\n"表示换行，"\r"表示回车

（三）整数类型

byte一个字节占8位
short一个字节占16位
int 一个字节占32位
long一个字节占64位
char 可以当做一中特殊的整数类型；

（四）浮点类型

在这里插入图片描述

2.基本数据类型的转换

（1）java中整数类型默认的int类型；小数类型默认的double；
（2）char 可以当做一中特殊的整数类型；
（3）int无法转换为boolean；
（4）boolean 类型不能转换成任何其它数据类型；

**默认类型转换与强制类型转换

（1）默认类型转换

①当“=”两侧的数据类型范围由小变大时，系统自动进行转换
②int直接赋值给byte\short\char，如果此int型数值尚在数值类型k范围内，jvm会自定进行一次隐式类型转换，将此int型数值转换成类型k。

（2）强制类型转换

①当“=”两侧的数据类型范围由大变小时，失精，必须进行强制类型转换
②进行数学运算时的数据类型自动提升范围大的那个，最后结果需要强制类型转换

例：进行数学运算时的数据类型自动提升，,结果需要强制类型转换
short s1 = 1; //系统自动将int变为short
s1 = s1 + 1; //错误: 等号左侧，混合运算成int，之后必须强制转换成short。
正确：s1=(short)(s1+1)
short s2 = 1;
s2 += 1; // 等同于short s2 = s2 + (short)1; //正确（主参②，系统将等号左边的1默认转换为int ->short: s2=+(short)1）

a.数值范围由小到大：
从存储范围小的类型到存储范围大的类型.

byte ->short(char)->int->long->float->double
在这里插入图片描述
需要注意的是：char型其本身是unsigned型，同时具有两个字节，其数值范围是0 ~ 2^16-1，因为，这直接导致byte型不能自动类型提升到char，char和short直接也不会发生自动类型提升（因为负数的问题），同时，byte当然可以直接提升到short型。

类型转换案例：

 public class TestConvert {
     public static void main(String arg[]) {
         int i1 = 123; 
         int i2 = 456;
         double d1 = (i1+i2)*1.2;//系统将转换为double型运算
         float f1 = (float)((i1+i2)*1.2);//需要加强制转换符
         byte b1 = 67; 
         byte b2 = 89;
         byte b3 = (byte)(b1+b2);//系统将转换为int型运算，需要强制转换符
         System.out.println(b3);
         double d2 = 1e200;
         float f2 = (float)d2;//会产生溢出
         System.out.println(f2);
         float f3 = 1.23f;//必须加f
         long l1 = 123;
         long l2 = 30000000000L;//必须加l
         float f = l1+l2+f3;//系统将转换为float型计算
         long l = (long)f;//强制转换会舍去小数部分（不是四舍五入）
     }
 }

三、运算符和表达式

在这里插入图片描述
1.i++与++i的区别：
++ i 是先加后赋值；i ++ 是先赋值后加。（单独使用时是一样的：i=i+1）

2.字符串连接运算符（+）
运算符两侧的操作中，只要含有一个操作数是字符串（String）类型，系统会将另一个操作数转化为字符串然后进行连接。

3.赋值运算符（=）
4.位运算符（待研究）

四、数组

1.一维数组

（1）数组的定义：

<类型> [] <名字> = new 类型 [元素个数]；

int [] a = new int [100];
double [] averages = new double [20];

注意：

元素的个数必须是整数
元素的个数必须给出
元素的个数可以变量

>例：输入一组数，求平均，并输出大于平均的数

public class Hello {
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		int[] number = new int[100]; // 定义数组
		int x = in.nextInt();
		int count = 0;
		int sum = 0;
		double avage = 0;
		while (x != -1)
		// 向数组里输入数
		{
			number[count] = x; // 对数组进行赋值
			count = count + 1;
			sum = sum + x;
			x = in.nextInt();
		}

		avage = sum / count; // 计算平均数
		// 输出大于平均数的数组（遍历数组）
		for (int i = 0; i <= count; i++)
		 {
			if (number[i] > avage)
			 {
				System.out.println(number[i]);
			}

		}
		System.out.println("平均数为" + avage);

	}
}

>优化版（先确定要求的个数，防止数组的溢出）

public class Hello {
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		double sum = 0;
		int count = 0;
		// 先确定数组的个数
		count = in.nextInt();
		if (count > 0) 
		{
			int[] numbers = new int[count];
			// 求数组求和
			for (int i = 0; i < numbers.length; i++) 
			{
				numbers[i] = in.nextInt();
				sum += numbers[i];
			}
			double avage = sum / count;
			// 找出大于平均数的数组
			for (int i = 0; i < count; i++)
			 {
				if (numbers[i] > avage) 
				{
					System.out.println(numbers[i]);
				}
			}
			// 输出平均数
			System.out.println("平均数为：" + avage);
		}
	}
}

（2）数组变量:

数组变量是数组的管理者而非数组本身
数组必须创建出来然后交给数组变量来管理
数组变量之间的赋值是管理权限的赋予
数组变量之间的比较是判断是否管理同一个数组

在这里插入图片描述

（3）复制数组：

必须便利源数组，将每一个元素注意拷贝到目的数组

	public class Hello {

	    public static void main(String[] args) {
	    	int [] a= {1,2,3,4,5};
	    	int [] b= new int [a.length];
	    	for(int i=0;i<a.length;i++)
	    	{
	    		b[i]=a[i];
	    	}
	    	for(int i=0; i<b.length;i++)
	    	{
	    		System.out.println(b[i]);
	    	}
	    }
	}

（4）for-each 循环（遍历集合、数组）

for (<类型><变量>：<数组>)
{
　　　//循环体内容
}

>例：用for-each循环查找数组内元素的

（在数组内我只需要找到是否有某个元素，而不用返回元素对应的数组下标时，for-each循环是一个不错的选择）

public class Hello {
	public static void main(String[] args) {	
		int [] data = {56, 75, 68, 45, 24, 245, 2, 5, 22, 27, 5};
		int x = 0;
		Scanner in = new Scanner ( System.in );
		x = in.nextInt();
		boolean found = false;
		for ( int k : data )
		   {
			if ( k==x )
			   {
				found = true;
				break;
			   }
		   }
		
		if ( found )
		   {
			System.out.println("找到了");
		   }

		else
			{
			System.out.println("没找到");
			}
		in.close();
	}
}

>用普通for循环查找数组内元素的

	public static void main(String[] args) {	
		int [] data = {56, 75, 68, 45, 24, 245, 2, 5, 22, 27, 5};
		int x = 0;
		Scanner in = new Scanner ( System.in );
		x = in.nextInt();
		int loc = 0;
		boolean found = false;
		for ( int i=0;i<data.length;i++ )
		   {
			if ( x==data[i] )
			   {
				found = true;
				loc=i;
				break;
			   }
		   }
		
		if ( found )
		   {
			System.out.println("找到了，下标为"+loc+"，是第"+(loc+1)+"个数");
		   }

		else
			{
			System.out.println("没找到");
			}
		in.close();
	}
}

>构造50以内的素数表

	public class Hello {
	    public static void main(String[] args) {
	    	int[] primes = new int[50];
	    	primes[0]=2;
	    	int cnt =1;
	    	MAIN_LOOP:
	    	for(int x=3;cnt < primes.length;x++)
	    	{
	    		for(int i=0;i<cnt;i++)
	    		{
	    			if(x%primes[i]==0)
	    			{
	    				continue MAIN_LOOP;
	    			}
	    		}
         //	    primes[cnt++]=x;
	    		primes[cnt]=x;
	    		cnt+=1;
	    	}
	    	for(int k:primes)
	    	{
	    		System.out.println(k+" ");
	    	}
	
	    }
	}

>构造n以内的素数表（将素数的倍数都标记出来）

	public class Hello {
	    public static void main(String[] args) {
	    	boolean []isPrime = new boolean[100];
	    	// 初始化都为true
	    	for(int i=0;i<isPrime.length;i++)
	    	{
	    		isPrime[i]=true;
	    	}
	    	//将每个素数的倍数都标记成false
	    	for(int i=2;i<isPrime.length;i++)
	    	{
	    		if(isPrime[i])
	    		{
	    			for(int k=2;i*k<isPrime.length;k++)
	    			{
	    				isPrime[i*k]=false;
	    			}
	    		}
	    	}
	    	//输出素数（输出下标）
	    	for(int i = 1;i<isPrime.length;i++)
	    	{
	    		if(isPrime[i])
	    		{
	    			System.out.println(i+" ");
	    		}
	    	}
	    }

}

2.二维数组

int [][]board=new int [SIZE][SIZE];

表示长度的方法：行：a.length 列： a[0].length

tic-tac-toe

3.补充：

（1）选择排序法和冒泡排序法：

两种排序方法都可以有小到大或由大到小

选择法排序的思路：
把第一位和其他所有的进行比较，只要比第一位小的，就换到第一个位置来
比较完后，第一位就是最小的
然后再从第二位和剩余的其他所有进行比较，只要比第二位小，就换到第二个位置来
比较完后，第二位就是第二小的
以此类推

package testa;

public class Demo {

	public static void main(String[] args) {

		int []a=new int [5];
		//将数组随机赋值，并打印出来
		for(int i =0;i<a.length;i++) {
			a[i]=(int)(Math.random()*100);
			System.out.println(a[i]);
		}
		System.out.println("");
		//选择排序
		//将第一个数与后面的数进行比较，如果小就交换
	for(int c=0;c<a.length-1;c++) {
		for(int i=c+1;i<a.length;i++) {
			if(a[i]>a[c]) {
				int b=a[c];
				a[c]=a[i];
				a[i]=b;	
			}

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

冒泡法排序的思路：
第一步：从第一位开始，把相邻两位进行比较
如果发现前面的比后面的大，就把大的数据交换在后面，循环比较完毕后，最后一位就是最大的
第二步：再来一次，只不过不用比较最后一位
以此

package testa;

public class Demo2 {
	
	public static void main(String [] args) {
		//创建一个数组并随机赋值，然后输入：
		int []aArray =new int[10];
		System.out.println("初始数组顺序:");
		for(int i=0;i< aArray.length;i++) {
			aArray[i]=(int)(Math.random()*100);
			System.out.println(aArray[i]+" ");
		}
		System.out.println(" ");
		//冒泡排序法：
	for(int c=0;c<aArray.length-1;c++) {
		for(int i=0;i<aArray.length-1-c;i++) {
				if(aArray[i]<aArray[i+1]) {
					int change =aArray[i+1];
					aArray[i+1]=aArray[i];
					aArray[i]=change;
				}
			
			}
	}
		for(int i=0;i<aArray.length;i++) {
			System.out.println(aArray[i]+" ");
		
		}
		
	}

}

（2）数组方法：

package testa;

import java.util.Arrays;

public class Demo3 {
	public static void main(String[] args) {
		boolean s= false;
		int []a=new int[10];
		for(int i=0;i<a.length;i++) {
			a[i]=(int)(Math.random()*100);
			System.out.println(a[i]);
		}
		System.out.println(" ");
		//数组的复制。
		int []b=Arrays.copyOfRange(a,0,2); //从下标0开始，到下标2，不含2。
		for(int i=0;i<b.length;i++) {
			System.out.println(b[i]);
		}
		
		//转化为字符串
		String w= Arrays.toString(a);
		System.out.println(w);
		//排序
		Arrays.sort(a);
		System.out.println(Arrays.toString(a));
		
	}

}

五、控制语句

1.条件语句if-else

（1）if语句、if嵌套语句：

if语句嵌套时，else总是和最近的if是一起的。

（2）级联的if-else if：

int f;
if(x<0)
{f=-1;}	
else if(x==0)
{f=0;}
else
{f=2*x;}
System.out.println(f);//单一出口最好

（3）语句规范：

if与else必须加上大括号形成语句块
大括号内语句缩进为一个Tab的距离

2.多分支选择语句switch

switch（控制表达式）{
case 常量：//常量可以是常数，也可以是常数计算的表达式
      语句
case 常量：
      语句
default:
      语句
}

（1）控制表达式

数据类型：
1.整型：byte short int long char
2.枚举类型
3.String 字符串类型（PS:对JDK版本有要求，必须为1.7及以上版本）

（2）常量：

Java 常量，有2种意思：
（1）就是一个值，这个值本身，我们可以叫它常量，举几个例子：
整型常量: 123
实型常量：3.14
字符常量: ‘a’
逻辑常量：true、false
字符串常量：“helloworld”
（2）表示不可变的变量，这种也叫常量，从语法上来讲也就是，加上final，使用final关键字来修饰某个变量，然后只要赋值之后，就不能改变了，就不能再次被赋值了，据个例子：final int i = 0;

（3）常量表达式：

表达式里面只有常量的式子，比如1+2是常量表达式，如果定义a为常量1，那么a+2也是常量表达式。
如果定义变量a，那么a+2就不是常量表达式。
n=5是常量表达式

>例：利用swtich语句解决分段函数问题：（PS:并不简便，只用于理解Switch用法）**

/*方法：根据判断得出x对应的区间，然后，将对应区间赋值于字符串i，
然后利用switch判断i的具体值，进而匹配对应的计算表达式。*/
public class Hello {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
	       Scanner s = new Scanner(System.in);		//输入数据

	       double x = s.nextDouble();		//定义x为输入数据

	       String i = "";  		//定义字符串类型i

	       double result = 0;       //定义结果为浮点型

	       if (x<0)             //判断输入x符合的区间

	           i = "x<0";

	       else if(x==0)

	           i = "x==0";
	       else
	    	   i= "x>0";

	       switch (i){      //根据x所对应的case区间，对结果进行赋值

	           case "x<0":

	               result = -1;
	               break;

	           case "x==0":

	               result = 0;
	               break;
	               
	           case "x>0" :
	        	   
	        	   result = 2*x;
	        	   break;

	       }
	       System.out.print("分段函数的结果为：" + result);    //输出结果
	   }

>利用if语句解决分段函数问题（最简便）

public class Hello {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner in = new Scanner(System.in);
		int x= in.nextInt();
		int f=0;
		if(x<0)
		f =-1;
		else if (x==0)
			f =0;
		else
		f=2*x;
		System.out.println(f);
	   }
	}

3.break、continue、return语句

（1）break

结束当前整个循环，执行当前循环下边的语句。

public class Hello {
    public static void main(String[] args) {
    //循环打印1，2，3，4
    for (int i = 0; i < 5; i ++) 
        {
            if (i == 1) 
            {//当i等于1的时候
                break;//跳出当前循环
            }
            System.out.println(i);        
        }
    }
}

（2）continue

跳过本次循环体中余下尚未执行的语句，继续执行当前循环。可以理解为仅结束本次循环。

public class Hello {
    public static void main(String[] args) {
        //循环打印1，2，3，4
        for (int i = 0; i < 5; i++) 
        {
            if (i == 1) 
            {//当i等于1的时候
                continue;//继续执行外层循环
            }
            System.out.print(i);
        }
    }
}
输出结果：0234

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

    int i = 1;

    int s = ++i;  //先加后赋值 i=1+1=2;s=i=2;

    int x= i++;   //先赋值后加 x=2; i=2+1=3;

    System.out.println(i);

    System.out.println(s);

    System.out.println(x);
    		}
    		}

答案：“3, 2, 2”。

（3）return

4.while循环语句

>例2：自动售票机代码（whlie循环）先判断在执行

视频网址：
https://www.icourse163.org/learn/ZJU-1001541001?tid=1001617002#/learn/content?type=detail&id=1002096002&cid=1002212003&replay=true

public class Hello {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner in =new Scanner(System.in);
		//读入投币金额
		int balance=0;
		while (true)
		{
			System.out.print("请投币:");
			int amount =in.nextInt();

			balance=balance+amount;
			if (balance>=10) 
			{		
				//打印车票
				System.out.println("******************");
				System.out.println("*Java城际铁路专线 *");
				System.out.println("*   无指定座位票   *");
				System.out.println("*   票价：10元      *");
				System.out.println("******************");
				//计算并打印零钱
				System.out.println("找零："+(balance-10));
				balance=0; //找零后，balance清零
			}

		}
		
	   }

	}

5.do-while循环语句

>例：计算一个数的位数（do while循环）先执行在判断

视频网址：
https://www.icourse163.org/learn/ZJU-1001541001?tid=1001617002#/learn/content?type=detail&id=1002096002&cid=1002214007&replay=true

public class Hello {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner in = new Scanner(System.in);
		System.out.print("请输入数字：");
		int number= in.nextInt();
		int count=0;
	do
		{
			number=number/10; //从左向右数，每除10就少一位
			count=count+1;    //每除一次就加1
		}	while (number>0);		//注意后边的分号
		System.out.println("位数为："+count);
	
	   }

	}

>猜数游戏代码程序

视频网址：
https://www.icourse163.org/learn/ZJU-1001541001?tid=1001617002#/learn/content?type=detail&id=1002098001&cid=1002213005

public class Hello {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner in = new Scanner(System.in);
		int number =(int)Math.random()*100+1;   //[0,1)-->[0,100)--> [1,101)   
		//让电脑输入一个0~100随机数
		int a;
		int count =0;
		do{
			a= in.nextInt();
			count=count+1;
			if(a>number)
			{
				System.out.println("偏大");
			}
			else if (a<number)
			{
				System.out.println("偏小");
			}
		}while(a!=number);
		System.out.println("恭喜你猜对了"+count+"次");
		
		

		
	   }

	}

>例3：输入一个正整数，按逆序输出

视频地址：https://www.icourse163.org/learn/ZJU-1001541001?tid=1001617002#/learn/content?type=detail&id=1002098001&cid=1002212011

public class Hello {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner in = new Scanner(System.in);
		int number =in.nextInt();
		int degital=0;
		int result=0;
		do{
			degital = number%10;   //求出每一位上的数字
			number= number/10; // 一次去掉每一位上的数字
			System.out.print(degital);// 输出每一位
			result=result*10+degital; // 去掉零的结果
		  }while(number!=0);
		System.out.println("");
		System.out.println("去掉零："+result);
	   }
      }

（3）for循环语句

1.定义：

for(语句A; 语句B; 语句C){
 
   //循环体
 
}

顺序：语句A→（语句B → 循环体 → 语句C）→（语句B → 循环体 → 语句C）→ … →退出循环

>例：求阶乘（for循环）

public class Hello {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner in = new Scanner(System.in);
		int n = in.nextInt();
		int factor=1;
		for(int i=1;i<=n;i++)
		{
			factor=factor*i;
		}
		System.out.println(factor);

2. 循环次数

for(int i=0;i<=n;i++) 循环次数=n+1 (带等号是为：前-后+1）
for(int i=0;i<n;i++) 循环次数=n (不带等号是为：前-后）

3. 三种循环使用场景：

有固定的次数时用for
必须先执行一次时用do whie
其他时候用 while

>例1：f(n)=1+1/2+1/3+1/4+…+1/n

public class Hello {
    		public static void main(String [] args){
    			Scanner in =new Scanner(System.in);
    			int n = in.nextInt();
    			double sum = 0.0;     //结果为小数，故用浮点型
    			for (int i =1;i <=n;i++)
    			{
					
					sum+=1.0/i;       //   1/n比定位小数，故用浮点型
    			}
    			System.out.println(sum);
    			System.out.printf("%.2f",sum);  // 使输出的结果保留小数点后两位
    		}
    		}

>例2：f(n)=1-1/2+1/3-1/4+…+1/n

public class Hello {
    		public static void main(String [] args){
    			Scanner in =new Scanner(System.in);
    			int n = in.nextInt();
    			double sum = 0.0;     //结果为小数，故用浮点型
    			int sign= 1;
    			for (int i =1;i <=n;i++)
    			{
					
//					sum+=sign*1.0/i; 
//					sign=-sign;   //   1/n比定位小数，故用浮点型   
    				
    				if(i%2==1)   //判断i是否为奇数
    				{ 
    					sum= sum+1.0/i;
    				}
    				else
    				{
    					sum=sum-1.0/i;
    				}
    			}
    			System.out.println(sum);
    			System.out.printf("%.2f",sum); 
    			// 使输出的结果保留小数点后两位
    		}
    		}

>例3：枚举法求两个数的最大公约数

public class Hello {
    		public static void main(String [] args){
    			Scanner in =new Scanner(System.in);
    			int a= in.nextInt();
    			int b =in.nextInt();
    			int result =1;
    			for (int i=2;i<=a&&i<=b;i++)
    			{
    				if(a%i==0)
    					{
    					    if(b%i==0)
    					    {
    						result=i;
    					    }
    					}
    			}
    			System.out.println(result);
    	
    		}
    		}

>例4：辗转相除法求两个数的最大公约数

public class Hello {
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		int a = in.nextInt();
		int b = in.nextInt();
		int oa = a;
		int ob = b;
		while (b != 0) 
		{
			int r = a % b;
			a = b;
			b = r;
		}
		System.out.println("输入的数为" + oa + "," + ob);
		System.out.println("最大公约数为" + a);

	}
}