JAVA初级笔记（1-13）

以下是我自己学习JAVA时整理的资料，很适合初学者阅读。

1、java开头

public class Test1 {
    //这是一个main的方法，是程序的入口
    public static void main(String[] args) {

    }
}

【1】main方法语法结构严格要求：
public static void main(String[] args){}
[修饰符1 修饰符2 …] 返回值类型 方法名(形式参数列表){
Java语句；… … …
}
【2】main方法：是程序的入口，在同一个类中，如果有多个方法，那么虚 拟机就会识别main方法，从这个方法作为程序的入口
注：
public static —>修饰符 ，暂时用这个 -->详见面向对象
void —>代表方法没有返回值 对应的类型void
main —>见名知意名字
String[] args —>形参 —》不确定因素

2、输出

对于简单独立的 Java 应用程序，编写一行输出数据的典型方式是：

   System.out.print("输出的内容:");

3、变量

案例：

int a;
a = 10;

int a = 10,a = 20;

int a , a1;

变量声明语法结构：
type varName [=value][,varName[=value]…];
//[ ]中的内容为可选项，即可有可无
数据类型 变量名 [=初始值] [,变量名 [=初始值]…];

4、数据类型的转化

public class TestVar10{
        public static void main(String[] args){
                //类型转换的两种形式：
                double d = 6;//int-->double  自动类型转换
                System.out.println(d);
                int i = (int)6.5;//double--->int  强制类型转换 （强转）
                System.out.println(i);

【1】语法结构：
type varName =（type）value
数据类型 变量名 =（数据类型）初始值
【2】
基本数据类型转化级别：(从低到高的)
byte,short,char–>int—>long—>float—>double

5、final

//一个变量被final修饰，这个变量就变成了一个常量，这个常量的值
//就不可变了
// 这个常量就是我们所说的 字符常量  ---》pi
// 约定俗成的规定：字符常量的名字全部大写
final double PI = 3.14;
               

语法结构：
final 数据类型 符号常量（字符常量）= 赋值；

6、扫描器

import java.util.Scanner;//形象理解：在java.util下将Scanner拿过来用
public class TestVar11{
        public static void main(String[] args){
 //【3】使用扫描器：Scanner的使用--》注意通过形象的理解去使用
        //拿来一个扫描器：
        Scanner sc = new Scanner(System.in);
        //给一个友好性的提示：
        System.out.print("");
        //让扫描器扫描键盘录入的int类型的数据：
        int r = sc.nextInt();
        //让扫描器扫描键盘录入的字符串，然后字符串---》字符
        String sexStr = sc.next();
        char sex = sexStr.charAt(字符的位置);
        //上面两句可以合为一句表示：char sex = sc.next().charAt(字符的位置);

语法结构：
Scanner 扫描器的名 = new Scanner(System.in)
数据类型 变量名 =扫描器的名 .nextInt()；

7、if单分支结构

  int a = 12;
        int b = 17;
        int c = 20;
        int d = 0;
        d += a;
        d += b;
        d += c;
        if (d>=29) {
            System.out.println("e");

语法结构:
if(布尔表达式){
语句块
}
if语句对布尔表达式进行一次判定，若判定为真，则执行{}中的语句块，否则跳过该语句块。

8、if多分支结构

        int a = 6;
        int b =10;
        int c = 20;
        int d = 0;
        d += a;
        d += b;
        d += c;
        System.out.println("和为："+d);
        if (d>=49) {
            System.out.println("你");
        }else if(d>=29){
            System.out.println("真");
        }else if(d>=12){
            System.out.println("好");
        }else{
            System.out.println("略略略");
        }

语法结构：
if(布尔表达式1) {
语句块1;
} else if(布尔表达式2) {
语句块2;
}……
else if(布尔表达式n){
语句块n;
} else {
语句块n+1;
}
当布尔表达式1为真时，执行语句块1；否则，判断布尔表达式2，当布尔表达式2为真时，执行语句块2；否则，继续判断布尔表达式3······；如果1~n个布尔表达式均判定为假时，则执行语句块n+1，也就是else部分。

9、if双分支结构

        int a = 6;
        int b =10;
        int c = 0;
        c += a;
        c += b;
        System.out.println("和为："+c);
        if (c>=12) {
            System.out.println("你真好");
        } else{
            System.out.println("略略略");
        }

语法结构:
if(布尔表达式){
语句块1
}else{
语句块2
}
当布尔表达式为真时，执行语句块1，否则，执行语句块2。也就是else部分。

9、随机数

 int c = (int)(Math.random()*6) +1;
        if (c>=3) {
            System.out.println("你真好");
        } else{
            System.out.println("略略略");

语法结构：
数据类型 变量名 = (数据类型)（Math.random()*倍数）+1

9、switch多分支结构

 int i = 4;
        switch(i) {
            case 1:
                System.out.println("你");
            case 2:
                System.out.println("是");break;
            case 3:
                System.out.println("谁");break;
            case 4:
                System.out.println("你从哪里来");break;
            default:
                System.out.println("default");
        }

语法结构：
switch (表达式) {
case 值1:
语句序列1;
[break];
case 值2:
语句序列2;
[break];
… … … … …
[default:默认语句;]
}
注：
()中表达式返回的结果是一个等值，这个等值的类型可以为：
int,byte,short,char,String,枚举类型

10、While循环结构

 int a = 1;//条件初始化
        int c = 0;
        while(a<=6){条件判断
            c += a;//循环体
            a++;//迭代
        }
       System.out.println(c);

while (布尔表达式) {
循环体;
}
注：
在循环刚开始时，会计算一次“布尔表达式”的值，若条件为真，执行循环体。而对于后来每一次额外的循环，都会在开始前重新计算一次。

11、do-While循环结构

 int a = 2;
        int c = 0;
        do{
            c += a;
            a++;
          }while(a<=24);
        System.out.println(c);

语法结构：
do {
循环体;
} while(布尔表达式) ;
注：
do-while循环结构会先执行循环体，然后再判断布尔表达式的值，若条件为真，执行循环体，当条件为假时结束循环。do-while循环的循环体至少执行一次。

11、for循环结构

int c = 0;
        for(int a = 1;a<=20;a++){
        // 条件初始化 条件判断  迭代
            c += a;//循环体
        }
        System.out.println(c);

语法结构：
for (初始表达式; 布尔表达式; 迭代因子) {
循环体;
}
注：
for循环语句是支持迭代的一种通用结构，是最有效、最灵活的循环结构。for循环在第一次反复之前要进行初始化，即执行初始表达式；随后，对布尔表达式进行判定，若判定结果为true，则执行循环体，否则，终止循环；最后在每一次反复的时候，进行某种形式的“步进”，即执行迭代因子。

12、增强for循环

ublic class Teat1 {
    public static void main(String[] args){
        int [][] a = new int[3][];
        a [0] = new int []{1,2,3};
        a [1] = new int []{4,2,5,6,7};
        a [2] = new int []{9,5,10,4,2,9};
        for(int i = 0; i<a.length;i++){
            for(int sum:a[i])
                System.out.print(sum+"\t");
        }
        System.out.println();
    }

语法结构：
for（ : ）{
}
注：
增强for循环：
优点：代码简单
缺点：单纯的增强for循环不能涉及跟索引有关的操作

13、方法的定义和调用

public class Test1 {
    public static void main(String[] args) {
        //方法的调用：（用方法）
        int sum = add(20,30);
        System.out.println("和为："+sum);
        //可以和为一句
        //  System.out.println("和为："+add(20,30));
    }
    //方法的定义：（写方法）
    public static int add(int num ,int num1){
        int sum = 0;
        sum += num;
        sum += num1;
        return sum;//将返回值返回到方法的调用处
    }

【1】方法声明语法结构：
[修饰符1 修饰符2 …] 返回值类型 方法名(形式参数列表){
Java语句；… …
}
【2】方法的调用方式：
对象名.方法名(实参列表)
【3】方法的详细说明
1、形式参数：在方法声明时用于接收外界传入的数据。
相当于告诉方法的调用者：---->需要传入几个参数，需要传入的参数的类型。
2、实参：调用方法时实际传给方法的数据。
实际参数：方法调用的时候传入的具体的参数： ---->根据形式参数的需要传入的。
3、返回值：方法在执行完毕后返还给调用它的环境的数据。
4、返回值对应的数据类型类型：事先约定的返回值的数据类型，如无返回值，必须显示指定为为void。
数据类型： 可以是基本数据类型：（byte,short,int,long,float,double,char,boolean） 也可以是引用数据类型
5、方法名 :见名知意，首字母小写，其余遵循驼峰命名
【4】方法的作用：提高代码的复用性

本文地址：https://blog.csdn.net/qq_54823276/article/details/114238838