华清远见重庆中心—后端基础阶段技术总结/个人总结

最新推荐文章于 2024-09-10 10:40:14 发布

M ai

最新推荐文章于 2024-09-10 10:40:14 发布

阅读量57

点赞数

文章标签： java Powered by 金山文档

本文链接：https://blog.csdn.net/m0_58356078/article/details/129245392

版权

1. Package（包）的命名：

/ com、cn、org... / 名称缩写、公司缩写 / 项目名称 /

例如： com.fs.test

Package：文件夹（目录）结构 com.fs.test com目录下有fs目录，fs目录下有test目录

2.新建Java Class文件

.java 文件名称首字母大写，

class + 类名：定义一个类

public 修饰了class，那么类的名称必须和.java文件名称保持一致

class没有public修饰，那么类名可以任意

在同一文件中可以定义多个类，但public的类只能有一个

3.main

public class Demo01 {

//    入口方法；main方法
//    重点：1、入口方法，除了形参的名称可以变之外，其余内容不可变
//         2、java文件运行起来时，一定会执行main方法（入口方法）

//    形参：args
    public static void main(String[] args){
        //System 系统
        //out 输出单元
        //println 控制台打印 ln:换行
        //System.out 中的. : '的'
        System.out.println("Hello");
        System.out.print("World");
        System.out.print("！！！");
    }

}

4.注释

文档注释：/** 内容 */ 快捷方式： /** + Enter

单行注释：// 内容（一般在内容上边，或者结尾右侧，快捷方式： Ctrl + /

多行注释：/* 内容 */

（注释一个代码片段（方法、方法中的某几行），快捷方式 /* + Enter */

/**
 * 文档注释：描述一个类
 * @class Demo03 这是描述注释的一个类
 */
public class Demo03 {

    //单行注释：注释一行内容（内容上边，或者结尾右侧）
    //        对变量或者常量注释，对某一行代码进行解释
    // 快捷方式： Ctrl + /

    /* 多行注释：注释一个代码片段（方法、方法中的某几行） */
    /* 快捷方式 /* + Enter */
    /*
    第一行
    第二行
    第三行
     */

    /**
     * 文档注释：可以注释一个方法，或者一个类
     * @method main 入口方法
     * @param args 形参的使用方式
     * 文档注释的快捷方式： /** + Enter
     */
    public static void main(String[] args){

        //年龄（非静态）
        int age = 18;//年龄（静态常量）

    }

}

5.标识符、关键字

标识符：

开头： _.$.字母

中间后面：_.$.字母.数字

驼峰法命名：myApple（小驼峰）命名变量、方法MyApple（大驼峰）命名类

下划线隔断法：my_apple

关键字：

50个关键字

其中有5个常见的保留字：goto const (true,false,null)

goto const 已经被弃用 true,false,null 作为值的类型存在java中

//重点：
//标识符 ：为 ”变量、类（接口）、方法“ 进行命名的符号
//标识符 ：1、标识符的开头只能以_、$、字母
//        2、标识符的中间和结尾以_、$、字母、数字为主要内容
//        3、不能以关键字或者特殊字符命名,(长度、大小写、换行)
//        4、见名知意(对变量进行特殊的名称定义，会帮助我们或者其他开发者理解程序功能,翻译软件)

//标识符常见的命名方式：1、驼峰法 我的苹果 ==> my apple ==> myApple MyApple
//                     首写字母小写 ：小驼峰法  主要用于变量、方法命名
//                     首写字母大写 ：大驼峰法  主要用于类 或者接口命名
//                  2、下划线隔断法  我的苹果 ==> my_apple

//关键字： 50个常见关键字
//       Java 由C/C++
//       其中有5个常见的保留字：goto const (true,false,null)
//       goto const 已经被弃用  true,false,null  作为值的类型存在java中
public class Demo04 {

public static void main(String[] args){

   int Math = 1;
   System.out.println(Math);

   int age = 12; //年龄
   int number = 12;//数字
   int year = 12;//年份
   int month = 12;//月份
   System.out.println(number);

   int myAge = 17;
}

}

6. Java数据类型

Java数据类型：1、基本数据类型 2、引用数据类型

基本数据类型

数值类型：byte short int long float double

字符类型：char

布尔值类型：boolean (true,false)

public class Demo05 {

    public static void main(String[] args) {

//        整数类型：int （byte short long）
        int a1 = 10; //十进制
        int a2 = 010; //八进制（逢八进一） 在数值前加0
        int a3 = 0x10; //十六进制（逢十六进一）在数值前加0x或者0X

         int n = 0173;
         int m = 0x7b;

        //结论：无论数值类型以何种方式表示，都是以十进制输出
        System.out.println(a1);
        System.out.println(a2);
        System.out.println(a3);
        System.out.println(n);
        System.out.println(m);

//        整数类型：long
//        为什么要用long类型？ int数值范围无法表示的情况下
//        所有整数数值类型默认为int
//        注意：long类型数值后需要加上L或者l
        long number = 2200000000l;
//        long number2 = 2100000000;//类型转化

//        浮点类型：float
//        注释：float定义浮点数类型时，需要加上F或者f
        float f1 = 0.01f;
//        float f2 = 1;//类型转化

//        浮点类型:double
        double d1 = 0.01;
//        科学进制表示方式 E:10的多少次方
        double d2 = 0.000000123;
        double d3 = 1.23E-7;//1.23 乘以 10的-7次方（小数点左移7位）
        float f3 = 1.23E-7F;

//        字符类型：char （基本数据类型）
//        char类型只能用单引号,单引号中只有一个字符或者数字

        char c1 = 'a';
        char c2 = '国';
        char c3 = 65; //ASCII码 65是一个计算机编码，对应'A'
        char c4 = '\u0000';//Unicode编码，空
//        转义字符：具有特殊的格式意义的字符
//        \n 换行  \t 制表符  \r 回车
        char c5 = '\t';

        System.out.println(c1);
        System.out.println(c2);
        System.out.println(c3);
        System.out.println(c4);
        System.out.println(c5);

//        System.out.println("Hello");//字符串（引用数据类型）
    }
}

一、运算符-->加减乘除

加、减、乘、除、取余（求模）

符号： + - * / %

两数相除：

两数都是整数类型，求整数商

两数任意一个是浮点数，求浮点数的商

运算表达式的最终类型，由运算表达式中的最大类型来决定。

运算的值可能存在溢出

public class Demo01 {

    //加、减、乘、除、取余（求模）
    public static void main(String[] args) {
        int a = 3;
        int b = 7;
        float c = 7.0f;

        System.out.println(a + b);//10
        System.out.println(a - b);//-4
        System.out.println(a * b);//21
        System.out.println(a / b);//0
        //求模运算为 %
        System.out.println(a % b);//3

        //两数相除：1、两数都是整数类型，求整数商
        //        2、两数任意一个是浮点数，求浮点数的商
        System.out.println(a / c);//0.42857143
        System.out.println(a % c);//3.0

        //数据类型表达式：
        // 运算表达式的最终类型，由运算表达式中的最大类型来决定。
        int n = 1;
        long m = 2;
        long l = n + m; //最终类型是long，因为m是最高的long类型
        double d = 1.2;
        double d2 = n + d;

        //注意：值溢出的风险。
        // int类型 2100000000
        int n1 = 210000;
        int n2 = 210000;
        int n3 = n1 * n2;//int 值溢出风险
        System.out.println(n3);

    }

}

二、自增自减

++ 自增

-- 自减

程序逻辑在方法中是严格从上往下执行的

赋值运算符：= 从右往左执行

注意表达式最终都是以结果形式显示

->b（变量）的值，与b++,++b （表达式）的值是有区别的

++a --> a先++，再输出a ( a=a+1 ; print(a) )

a++ -->先输出a，a再++ （ print(a) ; a=a+1 )

乘法的优先级高于减法

++ 和 -- 运算的优先级高于 + - * /

public class Demo02 {

    //++ -- 运算 （特殊运算）
    public static void main(String[] args) {

        //重点：程序逻辑在方法中是严格从上往下执行的

        //++ : 自加一
        //-- : 自减一
        int a = 5;
        a++;//a = a + 1 : =赋值运算从右往左
        System.out.println(a);
        a--;//a = a - 1
        System.out.println(a);

        //什么是表达式？ 例如：a-b; b++; ++b :注意表达式最终都是以结果形式显示
        //  b（变量）的值，与b++,++b （表达式）的值是有区别的
        // ++，--在变量”左侧“和“右侧”的区别

        int b = 1;
        int n = b++;//1
        System.out.println(b);//2
        int m = ++b;//3
        System.out.println(b);//3

        //重点 判断依据： 看运算符在前，还是变量在前。
        //  如果运算符在前，则先对值进行自加，再将值赋值给左侧
        //  如果是变量在前，则先把值赋值给左侧，再自加。
        System.out.println(n); //1 : b++ 将b的值先给左侧n，再进行自加一
        System.out.println(m); //3 : ++b b先进行自加一，再赋值给左侧的m

        //--运算 与 ++运算规则是一致的

        //问题:
        int i = 1;
        System.out.println(++i+i++);//
        System.out.println(i++-++i);

        //重点 ：运算优先级
        // 乘法的优先级高于减法。
        System.out.println(5 - 2 * 3);//-1
        // ++ 和 -- 运算的优先级高于 + - * /
    }
}

三、字符串拼接

字符串拼接符的判断依据：+ 的任意一侧有字符串出现时，它就是拼接符

字符串拼接符与普通的加减运算的优先级一致

拼接符的使用会直接消耗内存，执行效率低。

public class Demo03 {

    public static void main(String[] args) {
//        字符串拼接符
        String a = "abc";
        String b = "123";
        System.out.println(a + b);

//       重点：
//       字符串拼接符的判断依据：+ 的任意一侧有字符串出现时，它就是拼接符
//        字符串拼接符 与普通的加减运算的优先级一致。

        int i = 1;
        int j = 2;
        System.out.println(i + j + "3");//33
        System.out.println("3" + i + j);//312

//        拼接符的使用会直接消耗内存，执行效率低。
    }

}

四、赋值运算符

赋值运算符 = ：1、优先等级最低 2、从右往左运算

赋值运算的扩展运算符： += -= /= *= %=

public class Demo04 {
    //赋值运算符 = ：1、优先等级最低 2、从右往左运算
    //赋值运算的扩展运算符： += -= /= *= %=
    public static void main(String[] args) {
        int a = 1;//将1赋值给a变量

        int b = 2;
        b += a; //b = b + a
        System.out.println(b);//3
        b *= a;
        System.out.println(b);//3
        int c = 5;
        b %= c;//b = b % c
        System.out.println(b);//3
    }

}

五、交换两个数的值

1.使用中间变量tmp

public class Demo05 {

    public static void main(String[] args) {
//        交换两个数的值 a = 7; b = 3;
        int a = 3;
        int b = 7;

        a = b;//a = 7; b = 7;
        b = a;//a = 7; b = 7;
        需要定义一个中间量：
        int tmp;
        tmp = b;
        b = a;
        a = tmp;
        System.out.println("a = " + a);
        System.out.println("b = " + b);
    }
}

2.不使用中间变量（数学法）

public class Demo05 {

    public static void main(String[] args) {
//        交换两个数的值 a = 7; b = 3;
        int a = 3;
        int b = 7;
//        问题：不使用tmp的情况下交换两个数

        a = a + b;//a = 10,b = 7;
        b = a - b; //a = 10,b = 3;
        a = a - b;//a = 7,b = 3
        System.out.println("a = " + a);
        System.out.println("b = " + b);
    }
}

六、比较运算符

== 等号

=== 恒等引用数据类型

< , > , >= , <= , !=

a > b 表达式值 true false ：布尔表达式

public class Demo06 {

    //比较运算符
    // == 等号
    // === 恒等 引用数据类型
    // > , < , >= , <= ,!=
    public static void main(String[] args) {

        int a = 1;
        int b = 2;
        System.out.println(a > b); //false
        //a > b 表达式值 true false ：布尔表达式

        //数值类型比较
        System.out.println(a > b);
        System.out.println(a >= b);
        System.out.println(a < b);
        System.out.println(a <= b);
        System.out.println(a == b);
        System.out.println(a != b);

        int i = 0;
        double j = 0.0;
        System.out.println(i == j);//true
//        System.out.println(1 / i);//报错
//        System.out.println(1 / j);//Infinity 无限

        //字符类型的比较
        char c1 = 'a';//97
        char c2 = 'b';//98
        //字符类型的比较是通过ASCII所对应的十进制编码进行比较
        System.out.println(c1 > c2);//false
        System.out.println(c1 < c2);//true
        System.out.println(c1 > 96);//true

        //字符串类型的比较:字符串的不能用大小关系比较
        String s1 = "a";
        String s2 = "b";
        System.out.println(s1 == s2);
        System.out.println(s1 != s2);

        //多个比较运算符
        System.out.println(a > b & b == a);
    }

}

七、逻辑运算符

逻辑运算符的左右两侧，必须是布尔表达式

布尔表达式(boolean)：表达式的值必须是true或者false

1.与：&&、& 一假即假,全真为真

短路与：&&

条件1 && 条件2 && 条件3 ...

如果”条件1“为false，那么后续的条件就没有判断的必要。

逻辑与：&

条件1 & 条件2 & 条件3 ...

即便”条件1“为false，后续的条件仍要继续判断。

2.或：||、| 一真即真,全假为假

短路或：||

条件1 || 条件2 || 条件3 ...

如果”条件1“为true，那么后续的条件就没有判断的必要。

逻辑或：|

条件1 | 条件2 | 条件3 ...

如果”条件1“为true，后续的条件仍要继续判断。

逻辑与的优先级高于逻辑或，所以先执行与运算。

非运算高于”与，或“运算。（仅次于括号的优先级）

3.非！

取相反的布尔表达式的值

非的一侧必须是布尔表达式。

public class Demo07 {

    //重点： 逻辑运算符
    // 与 &&、&
    // 或 ||、|
    // 非 ！
    public static void main(String[] args) {

        //与：并且
        //比如：明天下雨，与打雷
        // 逻辑运算符的左右两侧，必须是布尔表达式
        // 布尔表达式：表达式的值必须是true或者false（boolean类型）

        int a = 1;
        int b = 2;
        int c = 3;

        //与：一假即假 （当所有布尔表达式中有为false的条件，结果必然为false）
        System.out.println(a < b && b < c);//true 真
        System.out.println(a > b && b < c);//false 假
        System.out.println(a > b && b > c);//false 假

        //或：可能
        //比如：明天下雨，或打雷

        //或：一真即真（当所有布尔表达式中有为true的条件，结果必然为true）
        System.out.println(a < b || b < c);//true 真
        System.out.println(a > b || b < c);//true 真
        System.out.println(a > b || b > c);//false 假

        //非：！取相反的布尔表达式的值
        // 注意：非的一侧必须是布尔表达式。
        System.out.println(!(a > b));//true

        //与  &&：短路与 &：逻辑与
        //或  ||：短路或 |：逻辑或

        //短路与：
        // 条件1 && 条件2 && 条件3 ...
        // 如果”条件1“为false，那么后续的条件就没有判断的必要。
        System.out.println(a > b && 1 / 0 > 0);//false

        //逻辑与：
        // 条件1 & 条件2 & 条件3 ...
        // 即便”条件1“为false，后续的条件仍要继续判断。
        System.out.println(a > b & 1 / 0 > 0);//出错

        //短路或 ||：如果前面的条件为真，那么后续的条件没有必要判断
        //逻辑或 |：即便前面的条件为真，后续的条件依旧需要判断

        //与或的混合判断
        // 逻辑与 的优先级高于 逻辑或，所以先执行与运算。
        // 注意：非运算 高于”与，或“运算。（仅次于括号的优先级）
        int d = 4;
        System.out.println(a > b && b < d || a > d && d > c);
    }

}

八、位运算

& 按位与：二进制比较，对位都为1结果为1

| 按位或：二进制比较，对位都为0结果为0

^ 异或：二进制比较，对位不相同结果为1

~ 非位：把所有二进制位取反(包含了符号位) (了解：乘除法)

public class Demo08 {

    //位运算
    public static void main(String[] args) {

        //二进制 （八进制，十六进制）
        // 二进制与十进制之间的转化

        //& 按位与 ：二进制比较，对位都为1结果为1
        //| 按位或 ：二进制比较，对位都为0结果为0
        System.out.println(3 & 7);
        System.out.println(3 | 7);

        //^ 异或： 二进制比较，对位不相同结果为1
        System.out.println(3 ^ 7);

        //了解：（乘除法）
        //~ 非位： 把所有二进制位取反(包含了符号位)
        System.out.println(~6);
        //移位运算
    }

}

九、

一、switch

格式：switch(数据值或变量){ case 值1:...; case 值2 :...;... }

括号中的数据类型，即switch中可以设置的类型有：(byte short int char String(Character))

switch不可以设置的类型有：long,double,float

有无break的情况（break 跳出（停止）switch语句）,没有break情况，程序会继续往后执行。

关于if语句与switch的区别：switch不能判断范围条件

default 除了case之外的其他条件，（default为了程序健壮性）

public class Demo01 {

    //switch语句
    //switch语句格式：switch(数据值或变量){ case 值1:...; case 值2 :...;... }
    public static void main(String[] args) {

        //选项卡：选择1 选择2 选择3...
        int n = 2; //选择的数据变量
        switch (n){
            case 1:
                System.out.println("n为1");
                break;//通过break可以终止整个switch语句
            case 2:
                System.out.println("n为2");
                break;//通过break可以终止整个switch语句
            case 3:
                System.out.println("n为3");
                break;//通过break可以终止整个switch语句
        }
        System.out.println("switch语句执行完成");

        //注意：1、switch括号中一般是变量，变量需要指定特殊的数据类型(byte short int char String(Character))
        //        switch不可以设置的类型有：long,double,float

        //注意：2、有无break的情况（break 跳出（停止）switch语句）,没有break情况，程序会继续往后执行。
        //     3、关于if语句与switch的区别：switch不能判断范围条件.

        //     4、default 除了case之外的其他条件，（default为了程序健壮性）
        int m = 5;
        switch (m){
            case 1:
                System.out.println("1");
                break;
            case 2:
                System.out.println("2");
                break;
            case 3:
                System.out.println("3");
                break;
            default://不存在前面所有条件的情况
                System.out.println("其它数字");
                break;
        }
    }
}

二、for循环

public class Demo03 {

    //for循环
    //for循环格式 for(初始化内容;结束循环条件;变化方式){...}
    //初始化内容：int i = 0
    //结束循环条件: i < 5 (布尔表达式)
    //变化方式: i++

    public static void main(String[] args) {

        //循环是什么：解决重复代码问题。
        //举例：重复打印Hello World 50遍
        for(int i = 0; i < 50; i++){
            System.out.println(i);
        }

        //循环的特殊结构
        //死循环:循环没有结束条件
//        for(int i = 0;;i++){}
//        for(int i = 0;i < 5;){}
//        for(;;){}

        for(int i=0,j=10;i < 9 && j > 3;j--,i++){
            System.out.println(i + ":" + j);
        }

    }
}

三、while循环

四、do-while循环

五、break、continue

一、数组

简单定义：将一类数据方到一个整体中

专业定义：将数据类型相同的数据，放到一个集合中

数组的定义方式：①静态初始化 ②动态初始化

静态初始化 : 在构建数组时就给予初始化的值

数组类型：数据类型[]、变量[]

int[] a = {1,2,3};

int b[] = {1,2,3};

动态初始化：先构建数组的对象，然后在逐一赋值初始化

格式：

数据类型[] 变量名 = new 数据类型[数组的长度]

int[] c = new int[3];

数组的类型决定了元素是什么样的类型

public class Demo01 {
    //重点：数组 :
    // 简单定：义将一类数据方到一个整体中
    // 专业定义：将数据类型相同的数据，放到一个集合中
    public static void main(String[] args) {
        //数组的定义方式：1、静态初始化  2、动态初始化

        //1、静态初始化 : 在构建数组时就给予初始化的值
        //数组类型： 数据类型[]、变量[]
        //数组初始化 {数组元素,数组元素,....}
        int[] a = {1,2,3};//1、数组有3个元素长度 2,里面的元素有哪些
        int b[] = {1,2,3};

        //2、动态初始化 ：先构建数组的对象，然后在逐一赋值初始化
        // 基本格式： 数据类型[] 变量名 = new 数据类型[数组的长度]
        int[] c = new int[3];//1、数组有多长

        //注意：数组的类型决定了元素是什么样的类型

    }

}

M ai

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
华清远见重庆中心—后端基础阶段技术总结/个人总结

括号中的数据类型，即switch中可以设置的类型有：(byte short int char String(Character))单行注释：// 内容（一般在内容上边，或者结尾右侧，快捷方式： Ctrl + /（注释一个代码片段（方法、方法中的某几行），快捷方式 /* + Enter */++a --> a先++，再输出a ( a=a+1;print(a) )a++ -->先输出a，a再++ （ print(a);文档注释：/** 内容 */ 快捷方式： /** + Enter。
复制链接

扫一扫