Java【基础】1-基本语法

关键字

标识符

变量

变量的分类

关键字

关键字中所有字母都为小写

标识符

Java对各种变量、方法和类等要素命名时使用的字符序列称为标识符

命名规则

由26个英文字母大小写、0-9，_或$符组成
数字不可以为开头
不可以使用关键字或保留字
Java中严格区分大小写，长度无限制
标识符不能含空格。

命名规范

包名：多单词组成时所有字母都小写
类名、接口名：多单词组成时，所有单词首字母大写
变量名、方法名：多单词组成是，第一个单词首字母小写，第二个单词开始后字母大写
常量名：所有字母都大写，多单词时每个单词由下划线连接

变量

变量的分类

基本数据类型变量间转换

基本数据类型与String间转换

变量的使用说明

整型变量

整型：byte、short、int、long
声明long型变量，必须以“l”或者“L”结尾。

浮点型变量

float：4字节，double：8字节。
定义float类型变量以“l”或者“L”结尾

char型变量

char：2字节。
定义：使用一对单引号
直接使用Unicode值来表示字符型常量

boolean型变量

常常在条件判断、循环结构中使用

bollean isMarried = true;
if(isMarried){
    System.out.println("你结婚了");
}else{
    System.out.println("你单身";
}

运算

自动类型提升

当容量小的数据类型的变量与容量大的数据类型的变量做运算时，结果自动提升为容量大的数据类型
byte-->short-->int-->long-->float-->double

当byte、short、char、三者之间数据类型做运算时结果为int

public class yunsuan {
    public static void main(String[] args) {
        byte b1 = 2;
        int i1 = 129;
        int i2 = b1 + i1;
        System.out.println(i2);
    }
}


//131

强制类型转换

强制类型转换的逆运算

        double d1 = 12.3;
        int i3 = (int)d1;
        System.out.println(i3);

//12

强转符（）

String类型使用

String属于引用类型变量：字符串

声明String类型使用 ""
Srting可以进行8种基本数据类型运算，且只能做连接运算。

算术运算

算术运算符的使用

取余运算结果与被模数数的符号相同

赋值、比较、逻辑、位、三元运算符的使用

赋值运算符：=、+=、*=、/=、%=

三元运算符结构：（条件表达式）？表达式1：表达式2

条件表达式结果为boolean类型
如果表达是位true执行表达是1，否则执行表达式2。
表达式1和表达是2 应该满足可以统一类型
三元运算符可以嵌套使用

public class test {
    public static void main(String[] args) {
        int m = 12;
        int n = 5;
        int max = (m > n)? m : n;
        System.out.println(max);
    }
}
//12

运算符优先级

scanner

导包：import java.util.Scanner;
Scaner的实例化：Scanner scan = new Scanner(System.in);
调用Scanner类的相关方法，来获取指定类型的变量

import java.util.Scanner;
public class test {
    public static void main(String[] args) {
    Scanner scan = new Scanner(System.in);
    int num =scan.nextInt();
    System.out.println(num);
    }
}

程序流程控制

if-else

1、if(条件表达是){

执行代码块;

}

2、if(条件表达式){

执行代码块1；

}

else{

执行代码块2;

}

3、if(条件表达式1){

执行代码块1;

}

else if(条件表达式2）{

执行代码块2；

}

。。。。。

else{

执行代码块3；

}

switch

根据switch表达式中的值，依次匹配各个case中的常量。一旦匹配成功，则进入相应的case结构，调用其执行语句。当调用玩执行语句以后，则仍然继续向下执行其他case结构中的执行语句，直到遇到break关键字或此switch-case结构末尾结束为止。

switch结构中表达式只能是如下6中数据类型之一：byte、int、short、char、枚举类型、String类型

switch(表达式){

case 常量1:

语句1；

//break;

... ...

case 常量N:

语句N;

break;

default:

语句;

//break;

}

public class test {
    public static void main(String[] args) {
    int number = 2;
    switch (number){
        case 0:
        System.out.println("zero");
        case 1:
            System.out.println("one");
        case 2:
            System.out.println("two");
        case 3:
            System.out.println("three");
        default:
            System.out.println("other");
    }
    }
}
// two
// three
// other

for、do-while、while循环

循环结构的四个要素

初始化条件
循环条件（boolea类型）
循环体
迭代条件

public class test {
    public static void main(String[] args) {
        for (int i = 1;i<=5;i++){
            System.out.println("hello");
        }
    }
}
hello
hello
hello
hello
hello

public class test {
    public static void main(String[] args) {
     int i = 1;
     while(i<=100){
         if(i%2==0){
             System.out.println(i);
         }
         i++;
     }
    }
}

public class test {
    public static void main(String[] args) {
     int num = 1;
     do{
         if (num%2==0){
             System.out.println(num);
         }
         num++;
     }while(num<=100);
    }
}

while（true）

import java.util.Scanner;
public class test {
    public static void main(String[] args) {
     Scanner scan = new Scanner(System.in);
     int z = 0;
     int f = 0;
     while(true){
         int number = scan.nextInt();
         if (number>0){
             z++;
         }else if (number<0){
             f++;
         }else{
             break;
         }
     }
     System.out.println(z);
     System.out.println(f);
    }
}

public class test {
    public static void main(String[] args) {
        for (int i = 1;i<=9;i++){
            for (int j = 1;j<=i;j++){
                System.out.print(i +"*"+ j + "=" + (i*j) + " ");
            }
            System.out.println();
        }
    }
}

质数输出

public class test {
    public static void main(String[] args) {
        for (int i = 2;i<=100;i++){
            boolean isFlag = true;
            for (int j = 2;j<i;j++){
                if (i%j == 0){
                    isFlag = false;
                }
            }
            if (isFlag == true){
                System.out.println(i);
            }
        }
    }
}

优化

public class test {
    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        for (int i = 2;i<=100;i++){
            boolean isFlag = true;
            for (int j = 2;j<Math.sqrt(i);j++){
                if (i%j == 0){
                    isFlag = false;
                    break;
                }
            }
            if (isFlag == true){
                System.out.println(i);
            }
        }
        long end = System.currentTimeMillis();
        System.out.println("时间"+ (end-start));
    }
}

break、continue

使用范围

break：循环、switch-case 结束当前循环

continue：循环结束当次循环

关键字后面不能声明执行语句

结束指定标识的一层循环：

public class test {
    public static void main(String[] args) {
        lable:for (int i = 1;i<= 4;i++){
            for (int j = 1;j<=10;j++){
                if (j%4 == 0){
                    break lable;
                }
                System.out.print(j);
            }
            System.out.println();
        }
    }
}

项目一家庭账单收支明细

Utility

import java.util.Scanner;
/**
 Utility工具类：
 将不同的功能封装为方法，就是可以直接通过调用方法使用它的功能，而无需考虑具体的功能实现细节。
 */
public class Utility {
    private static Scanner scanner = new Scanner(System.in);
    /**
     用于界面菜单的选择。该方法读取键盘，如果用户键入’1’-’4’中的任意字符，则方法返回。返回值为用户键入字符。
     */
    public static char readMenuSelection() {
        char c;
        for (; ; ) {
            String str = readKeyBoard(1);
            c = str.charAt(0);
            if (c != '1' && c != '2' && c != '3' && c != '4') {
                System.out.print("选择错误，请重新输入：");
            } else break;
        }
        return c;
    }
    /**
     用于收入和支出金额的输入。该方法从键盘读取一个不超过4位长度的整数，并将其作为方法的返回值。
     */
    public static int readNumber() {
        int n;
        for (; ; ) {
            String str = readKeyBoard(4);
            try {
                n = Integer.parseInt(str);
                break;
            } catch (NumberFormatException e) {
                System.out.print("数字输入错误，请重新输入：");
            }
        }
        return n;
    }
    /**
     用于收入和支出说明的输入。该方法从键盘读取一个不超过8位长度的字符串，并将其作为方法的返回值。
     */
    public static String readString() {
        String str = readKeyBoard(8);
        return str;
    }

    /**
     用于确认选择的输入。该方法从键盘读取‘Y’或’N’，并将其作为方法的返回值。
     */
    public static char readConfirmSelection() {
        char c;
        for (; ; ) {
            String str = readKeyBoard(1).toUpperCase();
            c = str.charAt(0);
            if (c == 'Y' || c == 'N') {
                break;
            } else {
                System.out.print("选择错误，请重新输入：");
            }
        }
        return c;
    }


    private static String readKeyBoard(int limit) {
        String line = "";

        while (scanner.hasNext()) {
            line = scanner.nextLine();
            if (line.length() < 1 || line.length() > limit) {
                System.out.print("输入长度（不大于" + limit + "）错误，请重新输入：");
                continue;
            }
            break;
        }

        return line;
    }
}

public class FamilyAccount {
    public static void main(String[] args) {
//        用于记录用户收入支出的详情
        String details ="收支\t账户金额\t收支金额\t说   明\n";
//        初始金额
        int balance = 10000;
        boolean isFlag = true;
        while(isFlag){
            System.out.println("---------------家庭收支记账--------------------");
            System.out.println("               1.收支明细");
            System.out.println("               2.登记收入");
            System.out.println("               3.登记支出");
            System.out.println("               4.退   出\n");
            System.out.println("               请选择（1-4）");
            char selection = Utility.readMenuSelection();
            switch (selection){
                case '1':
//                    System.out.println("1.收支明细");
                    System.out.println("----------------当前收支明细----------------");
                    System.out.println(details);
                    System.out.println("------------------------------------------");
                    break;
                case '2':
//                    System.out.println("2.登记收入");
                    System.out.println("本次收入金额");
                    int money = Utility.readNumber();
                    System.out.println("本次收入说明");
                    String info = Utility.readString();
//                    处理blance
                    balance += money;

//                    处理detils
                    details += ("收入\t"+balance + "\t" + money + "\t"+"\t" + info +"\n");

                    System.out.println("----------------登记完成----------------");
                    break;
                case '3':
//                    System.out.println("3.登记支出");
                    System.out.println("本次支出金额");
                    int money1 = Utility.readNumber();
                    System.out.println("本次支出说明");
                    String info1 = Utility.readString();

//                    处理balance
                    if (balance >= money1){
                        balance -= money1;
                        details += ("支出\t"+balance + "\t" + money1 + "\t"+"\t" + info1 +"\n");
                    }else{
                        System.out.println("支出超出账户额度，支付失败");
                    }
                    System.out.println("----------------登记完成----------------");
                    break;
                case '4':
//                    System.out.println("4.退   出");
                    System.out.println("确认是否要退出（Y/N）");
                    char isExit = Utility.readConfirmSelection();
                    if (isExit == 'Y'){
                        isFlag = false;
                    }
//                    break;
            }
        }
    }
}