【JAVA】1.编程基础

 1.Java基本语法

JAVA基本格式：

修饰符 class 类名{

程序代码

}

public class java {
    public static void main(String[] args) {
        System.out.println("HelloWorld");
}

 public static void main(String[] args) {}   （对于初学者来说这个部分必须写，可以去百度其意思）

 2.java的注释 

int a = 10;     //定义一个整型变量                               （单行注释）

        

/* int a = 10;                                                             （多行注释）

int b = 20; */

        

/**    */                                                                       （文档注释）

3.java标识符

包名、类名、方法名等，这些符号被称为标识符。

        

标识符可以由字母数字下划线（_）和美元符号（$）组成，但不能以数字开头，不能是Java中的关键字。

4.Java中的常量

整型常量

十六进制：Oxff、OXaf3

八进制：O711、O123

十进制：127

        

        

浮点数常量（float为单精度浮点数，double为双精度浮点数）

2e3f    3.6d     0f       5.0e+23f

        

        

字符常量

'a'       '1'       '&'       '\r'        '\u0000'      其中，'\u0000'代表空白字符

        

        

字符串常量

"Helloworld"     "123"

        

        

布尔常量

有ture和false两个值，用于区分事物的真与假。

        

        

null常量

只有null一个值，表示对象的引用为空。

5.Java中的变量

变量的数据类型分为两种，基本数据类型和引用数据类型。

        

                                                                                  |—整数类型（byte,short,int,long）

                                                |—数值型—————|

                  |—基本数据类型—|—字符型（char）    |—浮点类型（float,doule）

                  |                             |—布尔型(boolean)

数据类型—|  

                  |                             ​​​|——类（class）

                  |—引用数据类型—|——接口（interface）

                                                |——数组

                                                |——枚举（enum）

                                                |——注解（annotation）

        

类型名                                占用空间                        取值范围

字符型（byte）              8位（1个字节）            （-2^7 ~ 2^7  -1）

短整型（short）             16位（2个字节）          （-2^15 ~ 2^15  -1）

整形（int）                     32位（4个字节）          （-2^31 ~ 2^31  -1）

长整型（long）               64位（8个字节）         （-2^63 ~ 2^63  -1）

        

long num = 220000000000L    超过范围要加L在后面

float f = 123.4f      为float赋值要加f

        

自动类型转换

byte b = 3;
int x = b;
//把byte类型的变量b转换成了int类型，无需特殊声明

强制类型转换

public class java {
    public static void main(String[] args) {
        int num = 4;
        byte b = (byte)num;
        System.out.println(b);
    }
}

byte b = num是错误的

byte b = (byte)num才是正确的

因为不能将int转变成byte，所以需要强制类型转换。

强制类型转换格式为：目标类型  变量名  =  （目标类型） 值;

选择结构语句（          A.  if                      B.  if...else                 C.   if...else if...else        ）

A.    if条件语句 

if （条件语句）{

        代码块

}

public class java {
    public static void main(String[] args) {
        int x = 5;
        if (x<10){
            x++;
        }
        System.out.println("x=" + x);
    }
}

B.    if…else语句

if （判断条件）{

        执行语句1

        ……

}else{

        执行语句2

        ……

}

public class java {
    public static void main(String[] args) {
        int x = 5;
        if (x>10){
            x++;
        }
        else x=3;
        System.out.println("x=" + x);
    }
}

 

 C.   if…else if…else语句

if （判断条件1）{

        执行语句1

}else if （判断条件2）{

        执行语句2

}

…

else if （判断条件n）{

        执行语句n

}else{

        执行语句n+1

}

 把x看作成绩，修改x的值即可判断是否合格

                                                                成绩75分  

public class java {
    public static void main(String[] args) {
        int x = 75;    //75分成绩
        if (x<60)
        System.out.println("不合格");
        else if (x>80){
            System.out.println("优秀");
        }
        else {
            System.out.println("合格");
        }
    }
}

 

                                                                  成绩59分   

public class java {
    public static void main(String[] args) {
        int x = 59;    //59分成绩
        if (x<60)
        System.out.println("不合格");
        else if (x>80){
            System.out.println("优秀");
        }
        else {
            System.out.println("合格");
        }
    }
}

switch语句

switch的格式：

swtich（表达式）{

        case 目标值1：

                执行语句1

                break；

        case 目标值2：

                执行语句

                break；

        ……

        case 目标值n：

                执行语句n

                break；

        default：

                执行语句n+1

                break；

} 

                                                      switch  应用例子

public class java {
    public static void main(String[] args) {
        int week = 3;
        switch (week) {
            case 1:
                System.out.println("星期一");
                break;
            case 2:
                System.out.println("星期二");
                break;
            case 3:
                System.out.println("星期三");
            default:
                System.out.println("数字不正确")
        }
    }
}

                                                week的值改为2就是星期二

public class java {
    public static void main(String[] args) {
        int week = 2;
        switch (week) {
            case 1:
                System.out.println("星期一");
                break;
            case 2:
                System.out.println("星期二");
                break;
            case 3:
                System.out.println("星期三");
            default:
                System.out.println("数字不正确")
        }
    }
}

                                 如果week值没有对应的case就会输出default的System.out.println（）

public class java {
    public static void main(String[] args) {
        int week = 8;
        switch (week) {
            case 1:
                System.out.println("星期一");
                break;
            case 2:
                System.out.println("星期二");
                break;
            case 3:
                System.out.println("星期三");
            default:
                System.out.println("数字不正确");
        }
    }
}

循环语句结构（           A.  while               B. do...while          C.  for           ）

A.   while循环语句

while循环语句格式：

while (循环条件) {

        执行语句

        ……

}                            

public class java {
    public static void main(String[] args) {
        int x=1;
        while (x<6){
            System.out.println("x现在是：" + x);
            x++;
        }
    }
}

 x = 1，如果x<6才会跳出while的循环。x++是每次循环x的值都会+1。

执行过程：

        

x = 1，小于6，输出：x现在是：1，    然后x++，现在x=2

x = 2，小于6，输出：x现在是：2，    然后x++，现在x=3

……

x = 5，小于6，输出：x现在是：5，    然后x++，现在x=6

x=6，不小于6，跳出循环。

B.    do...while循环语句

do...while循环语句格式：

do {                           

        执行语句

        ……

} while (循环条件) ；

                                                   x = 6 时，停止循环

public class java {
    public static void main(String[] args) {
        int x=1;
        do {
            System.out.println("x现在是："+x);
            x++;
        }while (x<=6);
    }
}

  

do...while与while的区别：

(1条消息) while 循环和do...while循环的区别_不爱兰州拉面的小卢的博客-CSDN博客https://blog.csdn.net/dashuss/article/details/119281210

                      while     先判断条件再执行，             do...while     先执行在判断条件。

C.for循环

for循环语句格式：

for (初始表达式；循环条件；操作表达式) {

        执行语句

        ……

}

                                             求1+2+...+x的值（用for循环语句完成）

我们假设x=7，所以我们就是求1加到7（1+2+3+4+5+6+7）

public class java {
    public static void main(String[] args) {
        int sum = 0;
        for (int x = 1;x <= 3; x++){
            sum += x;
        }
        System.out.println("sum += " + sum);
    }
}

+=是什么意思解释

循环嵌套（循环里面还有循环） 

例如

for (初始表达式；循环条件；操作表达式) {

        ……

        for (初始表达式；循环条件；操作表达式) {

                执行语句

                ……

        }

        ……

}

                                                          打印星星矩阵

public class java {
    public static void main(String[] args) {
        for(int i=1;i<=5;i++){           //外循环
            for(int j=1;j<=i;j++)        //内循环
            {
                System.out.print("*");    //打印
            }
            System.out.println("\n");
        }
    }
}

 

\n  代表换行

执行过程

i=1，i<=5，j=1，j<=i（i现在是1），输出*，j++，此时j是2，但不小于等于 i（i现在是1），不输出*，然后外循环的换行

        

i=2，i<=5，j=1，j<=i（i现在是2），输出*，j++，此时j是2，j 满足条件小于等于2，输出*

j++后 j = 3 不满足条件，不输出*，然后执行外循环的换行。

        

……

        

总结：i=1时，输出1颗星，然后(\n)换行。       i=2时，输出2颗星，然后(\n)换行。……

跳转语句（break、continue） 

1.break语句：

先看一段代码：

public class java {
    public static void main(String[] args) {
        int x = 1;
        while (x <= 4) {
            System.out.println("x=" + x);
            x++;
        }
    }
}

                                                        break可以跳出循环

public class java {
    public static void main(String[] args) {
        int x = 1;
        while (x <= 4) {
            System.out.println("x=" + x);
            if (x == 3){
                break;
            }
            x++;
        }
    }
}

 

原本循环到 x = 4，现在循环只到 x = 3 就结束了。

注：break只能跳出内层循环，如果需要跳出外层循环，需要对外层循环添加标记。

continue语句

作用：终止本次循环，执行下一次循环。

                                       求5以内的奇数和，包括5（ 1+3+5 = 9 ）

public class java {
    public static void main(String[] args) {
        int sum = 0;
        for (int i = 1;i <= 5;i++){
            if (i % 2 == 0) {
                continue;
            }
            sum += i;
        }
        System.out.println("sum +="+sum);
    }
}

 

执行过程

i=1，i <= 5，i%2不等于0，sum=0+1，i++，现在i=2。

i=2，i <=5，i%2等于0，执行下一次循环，i++，现在i=3。

i=3，i <= 5，i%2不等于0，sum=0+1+3，i++，现在i=4。

i=4，i <= 5，i%2等于0，执行下一次循环，i++，现在i=5。

i=5，i <= 5，i%2不等于0，sum=0+1+3+5，i++，现在i=6。

结束循环

数组

在Java中，用下列两种方式定义一个数组。

int [ ] x = new int [100]；

        

或者

        

int [ ] x；                        //声明一个int[ ]类型的变量

x = new int [100]；        //创建一个长度为100的数组

public class java {
    public static void main(String[] args) {
        int [] arr = new int[3];
        arr[0]=1;
        arr[1]=2;
        arr[2]=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);
    }
}

 

 int [ ] arr = new int [3]意思是定义了3个int类型的变量，第一个变量名为arr[0]，第二个名为arr[1]。没有定义它的值时，初始值都为0。

public class java {
    public static void main(String[] args) {
        int [] 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);
    }
}

也可以把值都写在一个括号里，例如：

public class java {
    public static void main(String[] args) {
        int [] arr = {1,2,3,4};
        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[3]="+arr[3]);
    }
}

注：不能写成int [ ] x = new int [4]{1,2,3,4}；并且，上面的代码必须要有4个值，不然会报错：

public class java {
    public static void main(String[] args) {
        int [] arr = {1,2,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[3]="+arr[3]);
    }
}

 数组的遍历：

public class java {
    public static void main(String[] args) {
        int [] arr = {1,5,6,8,4,7};
        for (int i = 0;i < arr.length;i++){
            System.out.println(arr[i]);
        }
    }
}

数组的最大值：

public class java {
    public static void main(String[] args) {
        int [] arr = {1,5,6,8,4,7};
        int max = getMax (arr);
        System.out.println("max="+max);

    }

    private static int getMax(int[] arr) {
        int max = arr[0];
        for (int x = 1; x < arr.length; x++) {
            if (arr[x] > max) {
                max = arr[x];
            }
        }
        return max;
    }
}

数组排序：

冒泡排序（从小到大），冒泡排序是重点，必须   深刻理解      深刻理解     深刻理解     

public class java {
    public static void main(String[] args) {
        int [] arr = {1,5,6,8,4,7};
        for(int i=0;i<arr.length-1;i++)
        {
            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;
                }
            }
        }
        System.out.println("从小到大排序后的结果是:");
        for(int i=0;i<arr.length;i++)
            System.out.print(arr[i]+" ");
    }
}

 

 第一次先两两对比，最大的排后面，第二次除了最后一个，把最大的排后面，以此类推，直到没有可以对比的时候，就变成从小到大排序的数组。                                                                          

多维数组

int [ ] [ ] arr = new int [3] [4]

形成3*4的二维数组（3行4列）

arr[0][0]    arr[0][1]    arr[0][2]    arr[0][3]

arr[1][0]    arr[1][1]    arr[1][2]    arr[1][3]

arr[2][0]    arr[2][1]    arr[2][2]    arr[2][3]