Java必备基础一——一文读懂的Java基础中的基础

最新推荐文章于 2024-08-11 22:12:57 发布

Pandafz

最新推荐文章于 2024-08-11 22:12:57 发布

阅读量967

点赞数 12

分类专栏：《Java入门》系列文章标签： java 编程语言

本文链接：https://blog.csdn.net/Pandafz1997/article/details/117674499

版权

《Java入门》系列专栏收录该内容

19 篇文章 113 订阅

订阅专栏

内容虽然很简单，但是由于自己的基础很差，练习又太少，在编程这件事情上总是十分吃力，故记于此，长于心。
写在最后，打个鸡血，共勉：真正能让你走远的，都是自律、积极和勤奋。
程序人生，你可以靠努力去实现的人生。

本文已收录于[ 专栏 ]

🌳《Java入门》系列🌳

所有[ 章节 ]：

🎉🎉 Java学习笔记十七——集合类详细总结各自对比
 ✌ Java必备基础十六——三万字总结输入与输出流
 😀Java必备基础十五——万字长文总结异常处理基本知识点
 👋Java必备基础十四——内部类详细知识点归纳
 🤞Java必备基础十三——接口详细知识点归纳
 ✨Java必备基础十二——抽象类
 ✌Java必备基础十一——多态详解以及多态原则
 🙌Java必备基础十——类的继承详解
 😊Java必备基础九——包装类
 😎Java必备基础八——Math类、Random类、日期时间类
 👌Java必备基础七——字符串的基本常用方法
 😜Java必备基础六——一维数组
 👏Java必备基础五——类的封装
 🤳Java必备基础四——成员变量和局部变量
 👍Java必备基础三——方法的声明与调用，递归
 😘Java必备基础二——类和对象
 👍Java必备基础一——Java语言基础

一、Java语言基本格式

一个Java程序只有一个Java源文件为运行入口，此Java源文件要满足两个条件：该Java源文件中有一个类名与java源文件名称相同，且该类中必须有main方法；
一个Java源文件最多只有一个public类，且该public类名称一定和源文件名称相同；一个Java源文件为程序入口，若此Java源文件中有public类，则此类名称一定和.java文件名字要相同，主函数main方法一定在public类中，否则报错；
主函数书写格式为：

public static void main(String args[]){...};

方法名：访问控制符+修饰符+返回值类型修饰符号+方法名称；
publie：访问控制符号；static：静态修饰符；void：返回值类型修饰符，共同修饰main方法，

二、Java语言基本元素

2.1 Java语言使用的字符集

Unicode：采用双字节编码方式，每个字符编码由16位二进制数组成。

2.2 标识符

定义：包、类、方法、变量以及其它用户自定义项的名称，是一个有序的字符序列
书写规定：
1、标识符由字母、数字、__、$任意组合而成，首位不能为数字
2、标识符不能是Java语言的关键字与保留字，不能含有空格
3、标识符没有长度限制
4、大小写敏感
命名一般规则：
大驼峰（每个单词首字母大写）：类名、接口名
小驼峰（第一个单词首字母小写，其它单词的首字母大写）：变量、方法名

2.3 关键字与保留字

定义：用来声明数据类型、修饰方法或类
常用关键字：abstract、assert、boolean、break、byte、case、catch、char、class、const、continue、default、do、double、else、enum、extends、final、finally、float、for、goto、if、implements、import、instanceof、int、interface、long、native、new、package、private、protected、public、return、strictfp、short、static、super、switch、synchronized、this、throw、throws、transient、try、void、volatile、while
注意点：
1、Java中关键字都是小写
2、goto和const也被称为保留字，Java现在还没有用到，但以后可能会使用这两个关键字
3、true、false、null具有实际意义，严格来说不能算关键字；
4、用户自定义标识符不能使用关键字，也不能使用true、false、null、goto、const

三、Java书写规范

3.1 注释

单行注释（快捷键ctrl+/）（//）：多用于方法内，说明方法业务逻辑、某临时变量的含义、代码段的含义；
多行注释（快捷键ctrl+shift+/）（/* */）：用于除类、域、构造方法之外其它需要用到跨行解释的地方，如对某个自定义方法的注释说明
文档注释（file-setting-keymap-other-fix doc comment设置）（/** */）：一般用于类、域、方法之前

3.2 命名规范

采用合理的大小写混合方式
长度25以内
获取成员方法以get为前缀
boolean获取方法以is为前缀
除静态常量，命名避免使用下划线
静态常量全部用大写字母，单词间用__连接

3.3 文件样式与其它书写规范

3.3.1 文件样式规范

版权信息要在文件的开头
package要在import行之前，impo中包按照字母顺序排列
类注释包括文件名、类简介、更新时间以及辅助内容

/**
*@Author: 
*@Time: ${DATE} ${TIME}
*@Description
*/

公共的成员变量必须生成JavaDoc文档
同时存在多个同名构造函数时，应按照参数递增顺序书写构造函数
main函数应写在文件底部
一般情况下，每个类都有toString方法

3.3.2 其它书写规范

页面宽度设置为80个字符，过长语句，则要在都好或操作符后折行，折行后缩进3个字符
两个片段之间、类声明与接口声明之间应隔两个空行
局部变量与方法之间、两个方法之间、方法内两个逻辑块之间应隔一个空行
{与}中的语句应单独一行，（和）与内容之间不应该有空格
运算符的两边各有一个空格
格式自动调整快捷键（ctrl+alt+l）

四、基本数据类型

4.1 变量和常量

变量必须先声明后使用，变量代表一小段内存空间，变量可重新赋值；
常量一旦初始化就不可被修改，不能重新赋值，常量通常用final关键字声明。

4.2 数值型数据

4.2.1 数值型数据

整体类型：Java默认的整数直接量类型为int型

数据类型	类型	字节数	数据位数	数据范围
字节型	byte	1	8	-128~127
短整型	short	2	16	-32768~32767
基本整形	int	4	32	-2147483648~2147483647
长整型	long	8	64	-9223372036854775808~9223372036854775807

举个例子

public class Main {

    public static void main(String[] args) {
        // write your code here
        String s = "0";
        byte testByte = 123;
        short testShort = 30562;
        int testInt = 2000000000;
        long testLong = 39999999999999999L;
        Long result = testByte + testShort + testInt + testLong;
        System.out.println(result);
    }
}

4.3 浮点型类型

浮点型类型：表示带小数部分的数据类型

数据类型	类型	字节数	数据位数	数据范围
单精度浮点型	folat	4	32	1.4E₄₅3.402823538
双精度浮点型	double	8	64	4.9E-324~1.7976931348623157E308

举个例子：

public class Example2_1 {
    public static void main(String[] args) {
        double d3 = 1.2;
        float f1 = 1.2f;
        int i =201/10;
        System.out.println(i);

    }
}

4.4 字符型数据

数据类型	类型	字节数	数据位数	数据范围
字符型数据	char	2	16	-32768~32767
双精度浮点型	double	8	64	4.9E-324~1.7976931348623157E308

4.4.1 表达形式

用Unicode码表示：char c =’\u0041’;(范围从’\u000’~’\ufff’,可表示65536个字符)
直接通过单个字符表示：char c ='A’；
用整数表示字符：char c =65；
通过转义字符表示：char c =’\101’;char c =’\n’

转义字符	含义
\b	退格，将当前位置移到前一列
\n	换行，将当前位置移到下一行开头
\r	回车，将当前位置移到本行开头
\t	跳到下一个Tab位置
\	代表一个反斜线字符
’	单引号字符
"	双引号字符
\0	空字符（null）
\ddd	1~3位八进制数所代表字符

举个例子：

public class Example2_2 {
    public static void main(String args[]) {
        char a = 'A';
        char b = 65;
        char c = '\u0041';
        char d = '\377';
        System.out.println(a);
        System.out.println(b);
        System.out.println(d);
        System.out.println(c);
    }
}

4.4 布尔型数据

数据类型	类型	字节数	数据位数	数据范围
布尔型数据	char	1	8	-128~127

布尔型数据（逻辑型字符,常用于流程控制语句中的条件判断）（1）（-128~127）

bololean b = true；条件语句的判断为true时才会执行条件体里面的语句；
布尔函数的返回值只有两种（true或false）

五、运算符与表达式

5.1 算术运算符与算数表达式

运算符	功能描述
+	加(二元运算)
-	减(二元运算)
*	乘(二元运算)
/	除(二元运算)
%	取余(二元运算)
++	对运算符左边或右边的操1作数进行加操作（a++：先运算再赋值；a++：先赋值再运算）(一元运算)
–	b–：先运算再赋值；–b：先赋值再运算(一元运算)

5.2关系运算符与关系表达式

一般在条件判断中使用，返回值为true或false

运算符	功能描述	操作数据
>	左边是否大于右边	字符型，数值型
<	左边是否小于于右边	字符型、数值型
==	左边是否等于大于右边	基本数据类型、引用型
>=	左边是否大于等于右边	字符型、数值型
<=	左边是否小于等于右边	字符型、数值型
!=	左边是否不等于右边	基本数据类型、引用型

5.3 逻辑运算符与逻辑表达式

返回值为true或false

运算符	功能描述	说明
&&	短路与	都为true才为true，从左到右依次判断，节省计算机资源提高逻辑运算的速度
&	无条件与	全部都要判断
`\|\|`	短路或	全为false才为false，从左到右依次判断，节省计算机资源提高逻辑运算的速度
`\|`	无条件或	全部都要判断
^	异或	同为false异为true
!	取反	为取反值

5.4 赋值运算符

运算符	示范
=	int a =b=c=10，写法有误，应该先定义再赋值：int a，b，c；a=b=c=10;
+=	a+=10等价于a=a+10；
-=	a-=10等价于a=a—10；
*=	a=10等价于a=a10
/=	a/=10等价于a=a/10
%=	a%=10等价于a=a%10

5.5 条件运算符与条件表达式

格式：

（布尔表达式）？表达式1：表达式2

含义：当布尔表达式的值位为true时，结果为表达式1的值，否则为表达式2的值
举例

int max = (a>b)?a,b

5.6 其它运算符

5.6.1位运算符

运算符	功能描述	说明
&	按位与(&二元预算符)	两个操作数的每一位想与，0为false，1为true
`\|`	按位或（二元运算符）	两个操作数每一位相或，有1则为1
^	按位异或（二元运算符）	两操作数每一位异或，相同为0，不同为1
~	按位非（一元运算符）	操作数每一位取反

5.6.2 移位运算符

移位运算符（最高位为符号位，0为正，1为负，正数移位均补零，负数移位遵循左移低位补0，右移高位补1）

运算符	功能描述	举例
>>>	无符号向右移	-5>>>2=1073741822;
<<	向左移	5<<2=20
>>	向右移	5>>2=1

5.6 运算符优先级

从上到下优先级变低：
优先级：括号（）
正负号（+、—）
一元运算符（++ 、–、！）
乘除（*、%、/）
加减（+、—）
移位运算（>>、<<、>>>）
比较大小（>、<、>=、<=）
比较是否相等（==、！、=）
按位i与运算（&）
按位异或运算（^）
按位或运算（|）
逻辑与运算（&&）i
逻辑或运算（||）
三元运算（？w：）
赋值运算（=）

六、基本数据类型转换

6.1 强制类型转换

定义：强制显示的把一个数据类型转换为另外一个数据类型：

（targetvalue）value

举例：short m =（short）327

byte b =（byte）（a+b）

使用强制类型可能导致数值溢出或数据精度的下降

6.2 自动类型转换

Java中整数类型默认是int类型，小数类型默认是double类型
char可以当作是一种特殊的整数类型，Java语言规定byte，short、char三种类型的数据在进行算术运算时会自动转换成int类型
boolean类型不能与其它类型相互转换
小数类型转换成整数类型，小数可能被舍弃，会有精度损失，所以需要强制转换

七、流程控制

7.1 分支结构

7.7.1 if 条件语句

简单if语句

if（布尔表达式）{....}

if…else语句

if(布尔表达式){...}else{...}

if…else if语句

if(布尔表达式){...}else if(布尔表达式){...}else if（布尔表达式）{.....}

7.7.2 switch分支语句

语法

switch（表达式){
  case 值1:
 语句序列1
break；
  case 值2：
 语句序列2
break；
  case 值3：
语句序列3
break；
..............
default:
语句序列n
break；
}

说明
值1~n的值只能是整型（除long）、字符或字符串类型，break语句是可选项
1、满足值相同且当前值有break语句才会执行语句序列中的内容
2、如果表达式中的值与case语句中的值都不等，则执行default后的语句序列n+1；
3、若表达式的值与某一case语句中的值相同时，则执行对应的语句序列，遇到break语句时则跳出switch语句；
4、若swith语句中没有default语句，且表达式的值与case语句的值都不等，则程序直接跳出switch语句，不进行任何操作；
5、若没有break语句，则直接跳出switch语句，不进行任何操作；

举个例子：

package com.chapter3;

/**
 * 例子
 */
public final class ControlDemo {
    public static void main(String args[]) {
        int a = 123;
        int b = 243;
        System.out.println((a > b) ? a : b);

        if (a > b)
            System.out.println("a>=b");
        if (a < b) {
            System.out.println("a<b");
        }

        int c = 2;
        int d = 3;
        if (c >= d) {
            System.out.println("c>=d");
        } else {
            System.out.println("c<d");
        }

        int grade = 76;
        if (grade < 60) {
            System.out.println("不及格");
        } else if (grade >= 60 && grade < 75) {
            System.out.println("及格");
        } else if (grade >= 75 && grade < 85) {
            System.out.println("良好");
        } else if (grade >= 85) {
            System.out.println("良好");
        }

        int week = 7;
        switch (week) {
            case 1:
                System.out.println("周一");
                break;
            case 2:
                System.out.println("周二");
                break;
            case 3:
                System.out.println("周三");
                break;
            case 4:
                System.out.println("周四");
                break;
            case 5:
                System.out.println("周五");
                break;
            default:
            case 6:
                System.out.println("周六");
                break;

        }

        //计算1~100的和
        int sum = 0;
        int num = 1;
        while (num <= 100) {
            sum = sum + num;
            num++;
        }
        System.out.println(sum);
        //计算1~100的和
        int s = 0;
        int n = 1;
        do {
            s = s + n;
            n++;

        } while (n <= 100);
        System.out.println(sum);

        //for循环计算100以内奇数的和
        int sum1 = 0;
        for (int t = 0; t <= 100; t++) {
            if (t % 2 == 1) {
                sum1 = sum1 + t;
            } else {
                sum1 = sum1;
            }
        }
        System.out.println(sum1);

        //for循环输出九九乘法表
        for (int i = 1; i < 10; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.println(j + "*" + i + "=" + i * j + "");
                if (i == j) {
                    System.out.println();
                }
            }
        }

        //增强for循环,常用来遍历数组或集合
        String[] movies = {"这个杀手不太冷", "寂静岭", "过客", "两小无猜", "血钻", "魂断蓝桥"};
        for (String f : movies) {
            System.out.println(f);
        }


        //使用break跳出整个循环
        for (int i = 1; i <= 10; i++) {
            if (i % 3 == 0)
                break;
            System.out.println("i=" + i);
        }

        System.out.println();
        //使用break跳出当前内层循环
        int m;
        for (m = 1; m < 3; m++) {
            for (int j = 1; j <= 10; j++) {
                if (j == 4) break;
                System.out.println("m=" + m + "" + "j=" + j);
            }
            //内层循环结束时换行
            System.out.println();
        }
        System.out.println("退出循环时m=" + m);
    }

}

7.2 循环结构

7.2.1 while循环

先判断表达式再判断是否执行语句序列，true执行循环体内容，false跳出循环

while（布尔表达式）{
    语句序列 
}

7.2.2 do … while循环

先执行一次循环体再判断，再根据表达式判断是否需要再执行一次

do{
 语句序列
}while（布尔表达式）；

7.2.3 for循环

for（循环变量初始化；循环条件；循环变量调整语句）{
    语句序列
}

先初始化循环变量，只执行一次；再进行循环条件判断，最后根据判断执行语句序列
循环条件总是比循环体多执行一次，因为最后一次执行循环条件返回false时将不再执行循化体部分
for循环条件部分3个表达式之间用分号分隔，3个表达式可全部为空，但需要保留分隔符；，当3个表达式全部为空时，for循环将无限循环下去，直达遇到循环控制语句（break，continue）

		  /*
         * 标签语句由一个标识符后跟一个冒号构成
         * label1：
         * label2:

         out:
         while(true){
         inner:
         while(true){
         * continue;//语句一：结束当前内层循环的这次循环，继续内层循环
         * break;//语句二：结束当前的内层循环，从外循环开始再次进入内循环
         * continue out；//语句三：结束内循环，结束当前次外循环，重新从外循环进入内循环
         * break out；//语句四：结束内循环和外循环
         * }
         * }
         * */
			break语句：跳出本层循环，执行外循环
			continue语句：继续执行，不跳出内循环
			return语句：结束整个方法

举个例子：

package com.chapter3;

/**
 * @Author: qp
 * @Time: 2021/5/28 11:37
 * @Description 使用标签语句配合结束语句跳出循环体
 */
public class ControlCycleDemo {
    public static void main(String[] argsa) {
        /*
         * 标签语句由一个标识符后跟一个冒号构成
         * label1：
         * label2:

         out:
         while(true){
         inner:
         while(true){
         * continue;//语句一：结束当前内层循环的这次循环，继续内层循环
         * break;//语句二：结束当前的内层循环，从外循环开始再次进入内循环
         * continue out；//语句三：结束内循环，结束当前次外循环，重新从外循环进入内循环
         * break out；//语句四：结束内循环和外循环
         * }
         * }
         * */

        int i,j;

        System.out.println("loop1");
        loop:
        for(i =1;i<3;i++){
          for(j=1;j<4;j++){
              if(j==3){
                  continue; //结束本次内层循环，继续内循环
              }
              System.out.println("i="+i+"j="+j);
          }
          System.out.println();//内层循环结束,换行
        }

        System.out.println("loop2");//不执行
        loop:
        for (i=1;i<3;i++){
            for (j=1;j<4;j++){
                if(j==3){
                    break ;//结束整个内层循环，重新开始外循环
                }
                System.out.println("i="+i+"j="+j);
            }
            System.out.println();//内层循环结束,换行
        }

        System.out.println("loop3");//不执行
        loop:
        for (i=1;i<3;i++){
            for (j=1;j<4;j++){
                if(j==3){
                    continue loop; //结束当前次外循环，重新开始外循环
                }
                System.out.println("i="+i+"j="+j);
            }
            System.out.println();//不执行，整个跳出了内循环
        }


        System.out.println();//空一行
        System.out.println("loop4");
        loop:
        for (i=1;i<3;i++){
            for (j=1;j<4;j++){
                if(j==3){
                    break loop; //结束整个循环
                }
                System.out.println("i="+i+"j="+j);
            }
            System.out.println("循环体");//此条执行不到，跳出了整个循环
        }

//        使用continue语句输出1~10以内的偶数
        System.out.println();//空一行
        System.out.println("使用continue语句输出1~10以内的偶数");
        for(i=1;i<=10;i++){
            if(i%2!=0){
                continue;
            }
            System.out.println(i);
        }
    }
}

7.2.4 foreach循环

加强版for循环，用来遍历数组和集合。

for(float m:a){
 System.out.println(a);
}

等价于
for(int i;i<a.length;i++;){
 System.out.println(a[i]);
}

7.3循环控制

continue语句：跳出本次循环，continue之后的语句不再执行
return语句：结束整个方法，后面语句不再执行
break语句：跳出本层循环，执行外循环

八、数据的接收

Scanner类

定义：用来实现与用户进行交互，一般输入类型为String
方法以及返回类型：
close():关闭扫描器
hasNext():有下一个标记返回true
hasNextLine()：有下一行返回true
next()：返回下一个标记
nextLine()：返回当前行信息
reset()：重置
toString()：返回字符串
nextInt()：转换成int型
nextDouble():转换成double型

使用方法：

实例化对象 Scanner sc=new Scanner(System.in);
再通过对象调用Scanner类方法sc.next();

举个例子：

/**
 * @Author: qp
 * @Time: 2021/5/28 16:441
 * @Description Scanner类的运用：提供了与用户交互的方法
 */
class Example2_5 {

    public static void main(String[] y) {
//        如果判断为true，则执行return，不往下继续执行
//        如果判断为false，则不执行return，继续执行以下句子
//        String i="";
//        if (!isEmptyOrDot(i)){
//            return;
//        }
        Scanner scanner = new Scanner(System.in);
        String n = scanner.next();
        System.out.println(n);
        scanner.close();//关闭输入流，释放内存
    }

    private static boolean isEmptyOrDot(String str) {
       if("".equals(str)) {
           return false;
       }
       return ".".equals(str);
    }
}

九、举例

学习了这么多，关于循环需要注意以下：

continue：有内外层循环时，for内循环全部遍历，不满足条件继续内循环直达内循环遍历完全
break：不满足条件跳出for内部循环，继续执行for外部循环
return：不满足条件返回整个方法，内外循环均不执行，return后面方法均不执行
System.out.println()和 System.out.print()区别：print打印出来的内容是不能够自动换行的，而println可以，打印三角形的*时需要考虑使用：

最后举个例子：　打印下图

在这里插入图片描述

思路：
图片分为上部和下部：
上部分每一行需要打印八次，空格位由0到5，打印⭐的个数由8到3；
下部每一行的前五个位置均要用空格符占位，再打印*的个数由4到8；
代码实现如下：

   private static void prac2() {

        for (int j = 0; j < 6; j++) {
            for (int i = 0; i <= j; i++) {
                System.out.print(" ");//此处是打印空白且不换行
            }
            for (int i = 0; i <= (7 - j); i++) {
                System.out.print("*");
            }
            System.out.println("");//换行符
        }

        for (int j = 0; j < 5; j++) {
            for (int i = 0; i <= 5; i++) {
                System.out.print(" ");//此处是打印空白且不换行
            }

            for (int i = 0; i < j + 4; i++) {
                System.out.print("*");
            }

            System.out.println("");//换行符
        }


    }