Java的基本语法

1、代码的基本格式

修饰符  class 类名{

      程序执行代码

    }
    
public class HelloWorld(){
   //底下的main函数的写法是固定格式
	public static void main(String[] args){
		System.out.println("程序执行结果!");
	}
}

2、Java中的常量

  1. 整型常量(整数类型的数据)
  2. 浮点数常量(就是用到的小数,分为Float单精度浮点数和Double双精度浮点数)
  3. 字符常量(表示一个字符)
  4. 字符串常量(表示一串连续的字符)
  5. 布尔常量 (true、false)
  6. null常量(表示对象引用为空)

3、Java中的变量

变量:在程序运行期间,随时可以产生一些临时变量,应用程序会将这些数据保存在内存单元中,每个内存单元都用一个标识符来标识。这些内存单元被称为变量,定义的标识符就是变量名

int x = 0,y;      //作用是定义两个变量x和y,也就相当于分配了两个内存单元。
y = x+3;            //作用是为变量赋值



4、选择结构语句

4.1 if条件语句
4.1.1 if语句
if(条件语句){
代码块
}
案例(1):
public class Example01{
		public atatic void main(String[] args){
			int x = 5;
			if(x<10){
			x++;
		}
		System.out.println("x="+x);
	}
}
运行结果:x=6
4.1.2 if…else语句
if(判断条件){
        执行语句1
          ....     
    }else{
        执行语句2
          ....     
    }
    案例(1):
    public class Example {
     public static void main(String[] args) {
        int num = 19;
        if(num%2 == 0){
            //判断条件成立,num被2整除
            System.out.println("num是一个偶数");
        }else{
            System.out.println("num是一个奇数");
        }
    }
}
执行结果:num是一个奇数。

**注意:在Java中有一种特殊的运算叫做三元运算,它和if…else语句类似,语法如下:
*

判断条件 ?表达式1 :表达式2**

int x = 0;
int y = 1; 
int max;
if(x>y){
	max = x;
}else{
	max = y;
}
上面的代码可以用一句话解决:  int max = x>y ? x : y;      //当x>y这个条件成立是执行x,否则执行y;
4.1.3 switch语句

switch条件语句和if条件语句不同,它只能针对某个表达式的值做出判断,从而决定程序执行哪一个代码。

public class Example {
    public static void main(String[] args) {
       int week = 5;
       switch (week){
           case 1:
               System.out.println("星期一");
               break;
           case 2:
               System.out.println("星期二");
               break;
           case 3:
               System.out.println("星期三");
               break;
           case 4:
               System.out.println("星期四");
               break;
           case 5:
               System.out.println("星期五");
               break;
           case 6:
               System.out.println("星期六");
               break;
           case 7:
               System.out.println("星期日");
               break;   
           default:
               System.out.println("您输入的数字不正确");
               break;
       }
    }
}
执行结果:星期五
案例2:
public class fuxi {
    public static void main(String[] args) {
        int week = 2;
       switch (week){
           case 1:
           case 2:
           case 3:
           case 4:
           case 5:
               //当满足值1、2、3、4、5中任意一个时,处理方式相同
               System.out.println("今天是工作日");
               break;
           case 6:
           case 7:
               System.out.println("今天是休息日");
               break;
           default:
               System.out.println("您输入的数字不正确");
               break;
       }
    }
}
执行结果:今天是工作日

5、循环结构语句

5.1 while循环语句

while(循环条件){
	执行语句
}
案例1:
public class fuxi {
    public static void main(String[] args) {
        int x = 1;                   //定义变量x,初始值为1
        while(x<=4){               //循环条件
            System.out.println("x="+x);
            x++;
        }
    }
}
执行结果:x=1
		x=2
		x=3
		x=4

5.2 do… while循环语句(作用不大,了解就好)

5.3 for循环语句(重点掌握)

public class fuxi {
    public static void main(String[] args) {
       int  sum = 0;
        for (int i = 1; i < 4; i++) {
            sum+=i;
        }
        System.out.println("sum="+sum);
    }
}
执行结果:sum= 10;

嵌套循环:是指在一个循环语句的循环体中再定义一个循环语句的语法结构:

for(初始化表达式;循环条件;操作表达式){
	for(初始化表达式;循环条件;操作表达式){
		执行语句...
	}
}
案例:用“”*“”打印直角三角形
public class Triangle {
    public static void main(String[] args) {
        for (int i = 1; i < 9; i++) {     //外层循环
            for (int j = 1; j <= i; j++) { //内层循环
                System.out.print("*");
            }
            System.out.println();         //这句话只是一个换行作用
        }
    }
}

5.4 跳转语句(基本了解诶,作用不大)

  • break语句(当它出现在循环语句中,作用哪个是跳出循环语句,执行后面的代码)
  • continue语句(作用是终止本次循环,执行下一次循环。)

6、方法

方法的定义:

修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名 2,…){
执行语句
return 返回值;
}

  • 修饰符:方法的修饰符比较多,有访问权限进行限定的,有静态修饰符static,还有最终修饰符final等。
  • 返回值类型:用于限定方法返回值的数据类型。
  • 参数类型:用于限定调用方法时传入参数的数据类型。
  • 参数名:是一个变量,用于接收调用方法时传入的数据。
  • return关键词:用于结束方法以及返回方法指定类型的值。
  • 返回值:被return语句返回的值,该值会返回给调用者。
    - 方法的返回值必须为方法声明的返回值类型,如果方法中没有返回值,返回值类型要声明为void,return语句就可以省略
案例:
public class Example {
    public static void main(String[] args) {
       int area = getArea(3,5);        //调用getArea方法
        System.out.println("The area is"+area);
    }
    //定义一个求矩形面积的方法,接收两个参数,其中x为高,y为宽
    public static int getArea(int x,int y){
        int temp = x*y;             //把x*y的值赋值给temp
        return temp;                //将变量temp的值返回
    }
}
执行j结果:The area is 15

说明: 定义了一个getArea()方法用于求矩形的面积,参数x和y分别用于接收调用方法时传入的参数高和宽,
return语句用于返回计算所得的面积。
在main()函数中通过调用getArea()方法,获得矩形的面积。

6.1 方法的重载

案例:
public class Example {
    public static void main(String[] args) {
        //下面是针对求和方法的调用
        int sum1 = add(1,2);
        int sum2= add(1,2,3);
        double sum3 = add(1.2,2.3);
        System.out.println("sum1="+sum1);
        System.out.println("sum2="+sum2);
        System.out.println("sum1="+sum3);
    }
    //下面的方法
    public static int add(int x,int y){
        return x+y;
    }
    public static int add(int x,int y,int z){
        return x+y+z;
    }
    public static double add(double x,double y){
        return x+y;
    }
}
执行结果:sum1=3
		sum2=6
		sum1=3.5

7、数组(重点掌握)

(1)一维数组:
数组的定义:
【方法一】

int [] x = new int[100]; //直接声明一个长度为100的数组
也可以分成两句来写:
int[] x; //声明一个int[]类型的变量;
x = new int [100]; //创建一个长度为100的数组

new 的对象都在堆内存中。创建的变量都在栈内存中。

public class fuxi {
    public static void main(String[] args) {
        int[] arr;
        arr = new int[3];
        System.out.println("arr[0]="+arr[0]);
        System.out.println("arr[1]="+arr[1]);
        System.out.println("arr[2]="+arr[2]);
        System.out.println("数组的长度:"+arr.length);
    }
}
执行结果:arr[0]=0
		arr[1]=0
		arr[2]=0
		数组的长度:3

【方法二】

int [] arr = new int[]{1,2,3,4,5,6,7}; //直接赋值
int [] arr = {1,2,3,4,5,6,7}; // 直接静态初始化
用法还是同上。

7.1 数组的常见操作

  1. 数组遍历
    在操作数组时,经常需要一次访问数组中的每个元素,这种操作称为数组的遍历。
public class fuxi {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5,6,7};   //定义数组
        //使用for循环遍历数组的元素
        System.out.println("数组中的元素为:");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(" " + arr[i]);
        }
    }
}
执行结果:
数组中的元素为:
 1 2 3 4 5 6 7

(2)二维数组:
二维数组的定义方式有很多,常见的有:

  • 第一种方式

int[][] arr = new int [3][4]; //相当定义一个3*4的二维数组;

  • 第二种方式

int [][] arr = new int[3] []; //和第一种类似,只是数组中每个元素的长度不确定。

  • 第三种方式

int [][] arr = {{1,2,3},{,4,5,6},{7,8,9}};