Java笔记-JavaSE01-优快云博客

本文链接：https://blog.youkuaiyun.com/yyxwz_x/article/details/143838559

一.基础内容总结

1.标识符

表示类名的标识符用大写字母开始。

表示方法和变量的标识符用小写字母开始，后面的描述性词以大写开始。

所有的标识符都应该以字母（A-Z 或者 a-z）,美元符（$）、或者下划线（_）开始；

首字符之后可以是字母（A-Z 或者 a-z）,美元符（$）、下划线（_）或数字的任何字符组合

不能使用关键字作为变量名或方法名。标识符大小写敏感

2.数据类型

字符型用' '；字符串型用" "。

long型在数字后面加L；float型在数字后面加f。浮点型有时需要小数点，如10.0.

Java语言的整型常数默认为int型，浮点数默认是Double。

二进制需要0b开头；八进制需要0开头，十六进制需要0x或0X开头。

最好完全避免使用浮点数比较。原由：浮点数存在舍入误差，很多数字不能精确表示。如果需要进行不产生舍入误差的精确数字计算，需要使用BigDecimal类。

boolean类型（一位，0或1），boolean类型有两个值，true和false,不可以 0 或非 0 的整数替代 true 和 false ，这点和C语言不同。

3.类型转换

整型、实型（常量）、字符型数据可以混合运算。
运算中，不同类型的数据先转化为同一类型，然后进行运算。

在把容量大的类型转换为容量小的类型时必须使用强制类型转换。

转换过程中可能导致溢出或损失精度（由于容量不同）

容量小的数据类型可以自动转换为容量大的数据类型。

强制转换类型格式：(数据类型)值。

转换从低级到高级（根据容量）：

低 ------------------------------------> 高
byte,short,char—> int —> long—> float —> double

4.变量

类变量（静态变量： static variable）：独立于方法之外的变量，用 static 修饰。
实例变量（成员变量：member variable）：独立于方法之外的变量，不过没有 static 修饰。
局部变量（lacal variable）：类的方法中的变量。

局部变量没有默认值，局部变量被声明后，必须经过初始化，才可使用。

类变量和实例变量会自动初始化成该类型的默认初始值（数值型变量初始化成0或0.0，字符型变量的初始化值是16位的0，布尔型默认是false）。

public class Variable{
    static int allClicks=0; // 类变量
    String str="hello world"; // 实例变量
    public void method(){
        int i =0; // 局部变量
    }
}

变量命名规则：

1. 所有变量、方法、类名：见名知意
2. 类成员变量：首字母小写和驼峰原则 : monthSalary
3. 局部变量：首字母小写和驼峰原则
4. 常量：大写字母和下划线：MAX_VALUE
5. 类名：首字母大写和驼峰原则: Man, GoodMan
6. 方法名：首字母小写和驼峰原则: run(), runRun()

5.运算符

自增（++）自减（--）运算符是一种特殊的算术运算符，在算术运算符中需要两个操作数来进行运算，自增自减运算符是一个操作数，分为前缀和后缀两种。

public static void main(String[] args) {
    int a = 3;
    int b = a++; //执行完后,b=3。先给b赋值，再自增。
    int c = ++a; //执行完后,c=5。先自增,再给b赋值
}

与或非：

位运算符：

6.Scanner

下面是创建 Scanner 对象的基本语法：

Scanner s = new 1 Scanner(System.in);

使用时注意关闭（scanner.close();）

next和nextLine方式区别：next到空格停止（刚开始的空格忽略），后者则为整行输入。（输入enter之前的内容）

可用if或者while结合hasNextInt()或者hasNextFloat()等判断输入情况。（判断下次输入的类型）

7.if

if(布尔表达式 1){
    //如果布尔表达式 1的值为true执行代码
}else if(布尔表达式 2){
    //如果布尔表达式 2的值为true执行代码
}else if(布尔表达式 3){
    //如果布尔表达式 3的值为true执行代码
}else {
    //如果以上布尔表达式都不为true执行代码
}

8.switch

switch(expression){
    case value :
      //语句
      break; //可选，没有 break 语句出现，程序会继续执行下一条case语句，直到有break语句。
    case value :
      //语句
      break; //可选
    //你可以有任意数量的case语句
    default : //可选，default分支不需要break语句。
      //语句
}

9.while和do...while

while( 布尔表达式 ) {
    //循环内容
}

do {
    //代码语句
}while(布尔表达式);

do…while 循环和 while 循环相似，不同的是，do…while 循环至少会执行一次。

10.for

for(初始化; 布尔表达式; 更新) {
    //代码语句
}

11.增强for

for(声明语句 : 表达式)
{
    //代码句子
}

主要用于数组或集合的增强型 for 循环,遍历输出数组元素。

12.break和continue

break 主要用在循环语句或者 switch 语句中，用来跳出整个语句块。
break 跳出最里层的循环，并且继续执行该循环下面的语句。

continue 适用于任何循环控制结构中。作用是让程序立刻跳转到下一次循环的迭代。
在 for 循环中，continue 语句使程序立即跳转到更新语句。
在 while 或者 do…while 循环中，程序立即跳转到布尔表达式的判断语句。

break在任何循环语句的主体部分，均可用break控制循环的流程。break用于强行退出循环，不执行循环中剩余的语句。(break语句也在switch语句中使用)
continue 语句用在循环语句体中，用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定。

13.方法

语法：

修饰符 返回值类型 方法名(参数类型 参数名){
    ...
    方法体
    ...
return 返回值;
}

Java语言中使用下述形式调用方法：对象名.方法名(实参列表)

方法的重载：一个类的两个方法拥有相同的名字，但是有不同的参数列表。

重载的方法必须拥有不同的参数列表。不能仅仅依据修饰符或者返回类型的不同来重载方法。

14.递归

递归：自身调用自身，需要有边界条件停止自身调用

15.数组

声明方法：

dataType[] arrayRefVar; // 首选的方法
或
dataType arrayRefVar[]; // 效果相同，但不是首选方法
//eg.
int[] a;
int[] a = null;

创建方法：

arrayRefVar = new dataType[arraySize];
//eg.
a = new int[7];

声明+创建方法：

dataType[] arrayRefVar = new dataType[arraySize];
//eg.
int[] a = new int[1];

数组索引从0开始。下标的合法区间：[0, a.length-1]，如果越界就会报错.

初始化：

//静态初始化
int[] a = {1,2,3};
Man[] mans = {new Man(1,1),new Man(2,2)};
//动态初始化
int[] a = new int[2];//默认全0
a[0]=1;
a[1]=2;

多维数组（二维为例）：

格式：

type[][] typeName = new type[typeLength1][typeLength2];
//eg.
int[][] a = new int[1][2];

arraylenght1 为行数，arraylenght2 为列数。

a.length为数组行数（第一维长度），a[0].length是数组列数（第二维长度）。

16.Arrays

Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用,而"不用"使用对象来调用。

可以参考如下代码：

//打印数组中的全部数
public static void main(String[] args) {
    int[] a = {1,2};
    System.out.println(a); //[I@1b6d3586
    System.out.println(Arrays.toString(a)); //[1, 2]
}
//排序
public static void main(String[] args) {
    int[] a = {1,16,6,12,7,4,8};
    System.out.println(Arrays.toString(a));
    Arrays.sort(a);
    System.out.println(Arrays.toString(a));
}
//填充
public static void main(String[] args) {
    int[] a = {1,2,323,23,543,12,59};
    Arrays.sort(a); //使用二分法查找，必须先对数组进行排序
    Arrays.fill(a, 2, 4, 100); //将2到4索引的元素替换为100
    System.out.println(Arrays.toString(a));
}

二.练习代码

1.编辑一个计算器通过用户输入的两个数据实现加减乘除功能。

package homework;

import java.util.Scanner;

//编辑一个计算器 通过用户输入的两个数据实现加减乘除功能
public class Calculator {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        double a = 0;
        double b = 0;
        String str = null;
        if (scanner.hasNext()) { //输入需要计算的表达式形式如  9 * 1 （字符之间用空格隔开，回车键计算结果）
            a = scanner.nextDouble();
            str = scanner.next();
            b = scanner.nextDouble();
        }
        double result = calculate(a,b,str);
        System.out.println("计算结果是："+result);
        //System.out.println(a);
        //System.out.println(b);
        //System.out.println(str);

        scanner.close();
    }
    public  static double calculate(double a,double b,String str){
        double result = 0;

        switch (str){
            case "+":    // 注意使用""
                result=a+b;
                break;
            case "-":
                result=a-b;
                break;
            case "*":
                result=a*b;
                break;
            case "/":
                result=a/b;
                break;

        }
        return  result;
    }

}

2.使用冒泡排序法，对输入的数字进行升序排序，最后输出顺序

package array;

import java.util.Arrays;
import java.util.Scanner;

//编写冒泡排序算法
//1.输入数据
//2.排序
//3.输出
public class Practice {
    public static void main(String[] args) {
        System.out.println("输入所需要排序的数组");
        Scanner s = new Scanner(System.in);
        Double[] a = new Double[100000]; //支持最多输入10000个数字
        int b =0;//b用来记录输入的数字的个数
        //每输入一个数字按一次回车，若输入完毕则输入非数字即可结束输入
        //或者将全部数字一次性输入，数字之间空格隔开，输入任何一个非数字结束输入
        while(s.hasNextDouble()){
            a[b]=s.nextDouble();//记录输入的数字
            b++;//记录输入数字的个数
        }
        double[] c = new double[b];//创建新的数组c 去a中多余的0，对输入的数字重新记录
        for (int i = 0; i < b; i++) {
            c[i]=a[i]; //得到输入的数组c
        }
        c=sort(c);//排序
        //System.out.println(Arrays.toString(c));//输出排序后的数组
        System.out.print("将输入数据从小到大排序，其顺序为：" + c[0] + " ");
        for (int i = 1; i <c.length ; i++) {
            System.out.print(c[i] + " ");
        }
        s.close();//关闭
    }
    //创建排序方法 （冒泡排序法 升序排列）
    public static double[] sort (double[] c){
        double temp= 0;//定义缓存变量
        for (int i = 0; i < c.length-1; i++) { //需要比较几轮
            for (int j = 0; j < c.length - 1-i; j++) { //每论需要比较几次
                if (c[j] >= c[j + 1]) {//升序换位 若相同则顺序保持不变
                    temp = c[j];
                    c[j] = c[j + 1];
                    c[j + 1] = temp;
                }
            }
        }
        return c;
    }
}