Java 基础 ——入坑必读

发表于 分类于 阅读次数： 本文字数： 11k 阅读时长 ≈ 10 分钟

历史沿革

Java是印度尼西亚“爪哇岛”的英文名，因气候环境，地理位置等因素盛产咖啡而闻名。Java语言中的许多命名都与其有关：如JavaBeans。所以Sun和Java的Logo是个非常形象的图标—冒热气儿的咖啡

早期的Java只是Sun MicroSystems公司在1990年12月开始研究的一个内部项目。Sun公司一位名为帕特里克·诺顿的工程师因为其公司难于操作的C++/C语言编译器而决定改用NeXT，同时他也获得了研究公司的一个叫做“Stealth计划”的项目的机会

“Stealth计划”后来改名为“Green计划”，詹姆斯·高斯林和Mike Sheridan也加入了帕特里克的工作小组。根据有限资金，乔伊决定开发一种集C语言和Mesa语言大成的新语言，在一份报告上，乔伊把它叫做“未来”。他将要创造出一种全新的语言，被他命名为“Oak”，以办公室外的橡树命名

Java 语言基础

1.1 基本元素

1.1.1 标识符

（1）标识符包含类名、变量名、常量名、方法名…；

（2）命名规则：字母、下划线、美元符号开头，后可接此三种符号或0-9的数字，注意不要和关键字 重合；

（3）命名“约定”：变量名、方法名首单词小写，其余单词仅首字母大写。类名、接口名首字母大写

常量全都用大写字母、单词命名，下划线常用于常量名单词的分隔。Java严格区分字母大小写，例如aB和Ab是完全不同的合法标识符；

1.1.2 关键字

重点标记一些Java中特有的关键字：
（1)数据类型：boolean、byte、char、double、false、true、void、instanceof、float、int、long、new、null、short；

（2)语句：break、case、catch、continue、、return、super、switch、this、throw、try、while、default、do、else、finally、for、if；

（3)修饰：abstract、final、native、transient、volatile、private、protected、public、static、synchronized；

（4)方法、类、接口、包：interface、import、class、extends、 implements、package、throws；

1.1.3 保留字

一些不能用做自定义标识符，但又有自己专门用途和意义的 “ 关键字 ” ；形象的来讲就是他们没有成为关键字的权利，但是有享受关键字的“待遇”，像是充值VIP一般，sizeof、goto、const，它们仨就是VIP中的成员。说不定随着语言的发展，慢慢它们也成为关键字了呢？

1.1.4 分隔符

像C/C++中熟知的空白符（Tab、回车、空格、换行）、普通分隔符（点、分号、逗号……）、单行注释符 // 注释内容 ，多行注释符 /* 注释内容 */ 就不再详细展开来讲，这里我们主要了解Java中一些不一样的东西—Java文档注释格式，它的格式是/ * *注释内容 * /

注意：这类注释只应用在声明之前，最为方便的是它可以利用JDK中提供的 javadoc 工具，根据注释内容自动生成HTML代码说明文档

1.2 数据类型

那么，何为数据类型或者说数据类型能说明什么呢?它存在的意义就是：表明变量、常量、表达式的性质。在进行运算时，只有符合“相同数据类型”这一条件，才可以继续进行。按照大类区分，Java中有简单、引用两种数据类型。分类如图所示

1.2.1 基本数据类型

在使用计算机进行运算时，我们都知道不同的数据类型在其中表示的数值范围、所占内存大小都不相同，下表给出了Java基本数据类型的具体参数

表中，我们仍能对这些数据类型进行划分，比如byte、short、int、long、float、double属于数值型数据，char、boolean属于非数值型数据。Java因其基本数据类型拥有固定长度的特性，而促成了其基本数据类型优良的跨平台移植属性，数值类型的数据都与系统无关

1.2.2 变量

变量是程序中存储单元的标识符，它代表内存中的一块空间。在Java中，变量还具有类型、名称、值、作用域等属性

命名

遵循命名规则：

（1）长度不限，但系统仅承载前32个字符，变量名必须以小写字母开头，且首字符不能为数字；

（2）在同一作用域内，变量名必唯一且区分大小写；

（3）不能是关键字，布尔值或保留字（null)；

（4）若多个单词构成变量名，则单词需要连在一起写，且除第一个单词外，其余单词首字母需大写；

声明

两种声明格式：

1
2
3
4
5
 int a,b,c;
 float b1,i1;
 double c,c1=2d;  //声明变量同时初始化
（1）类型  变量名［变量名1,···变量名n];
（2）类型  变量名［变量名1,···交量名n]=初值，···;

初始化

变量声明后，使用赋值语句进行初始化：

1
2
3
varName1 = [ varName2 = ] 表达式 ;
int Var1,var2;
var1=var2=5;

允许同时给多个变量赋值：

1
2
类型 varName1 = 表达式1 [ , varName2 = 表达式2 ] ;
float Var1=2.3f,Var2=3.2f;

变量在声明的同时进行初始化：

1
2
类型 变量名=表达式;
double variable=600d;

注意：除可以进行自动类型转换的数据外，变量的赋值需要“＝”号两边的数据类型一致

作用域

变量要先定义后使用，变量定义所在的位置决定了变量的作用域，根据变量定义所处位置，其作用域可以分为：局部变量、类成员变量、方法参数变量、异常处理参数变量

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class TypeDefinition {
    static char charVar='\t'; //  类成员变量
    static final float floatVar=3.1415926f; //定义单精度浮点型常量floatVar       类成员变量
    public static void main(String[] args){
        String stringVar="Java";   //在该语句块中有效       
        System.out.println("类中定义:floatVar="+floatVar+charVar+"stringVar="+stringVar);
        System.out.println();  //光标换行
        show();
    }
    static void show(){
        String stringVar="Test";
        System.out.println("类中定义:floatVar="+floatVar);
        System.out.println("方法中定义:stringVar="+stringVar);
    }
}

类型转换

当数值在不同的数据类型之间进行运算时，需要转换为统一类型来进行，不同数据类型之间有对应的转换规则。可以分为 “ 自动类型转换 ” 和 “ 强制类型转换 ” 两种

自动类型转换也称 “ 隐式类型转换 ” ，即编码是不需要程序员操作，系统会自动进行类型转换，一般遵循低精度可以自动转换到高精度的规则

但是，如果数据由高精度转换成低精度呢？那么我们就需要进行强制类型转换
强制转换的格式为：

1
2
3
（数据类型）表达式 ;
int a;
byte c=byte(i); //int型数据a强制转换为byte型

注意：根据变量所占位长的不同，在强制类型转换中可能发生数据丢失的现象，使用需谨慎。下面展示强制转换后数据丢失的例子：

1
2
3
4
5
6
7
8
public class TypeConversion {
    public static void main(String[] args){
        int intVar=0xff56;
        byte byteVar=(byte)intVar;//数据强制类型转换 32位整数强制转换为8为字节数
        System.out.println("intVar="+Integer.toString(intVar,2)+";"+intVar); //转换为二进制,int型数据
        System.out.println("byteVar="+Integer.toString(byteVar,2)+";"+byteVar);//转换为二进制,字节型数据
    }
}      //整型数据int有32位,而byte字节型数据只有8位,类型转换后数据丢失

1.2.3 常量

常量是在程序中直接给出的一系类符号串，它的作用是为变量赋值或参与表达式的运算。可以是一个具体的数值或字符串。常量在程序执行过程中不可更改

常量标识符命名全部由大写字母组成，多个单词之间使用下划线进行连接，eg:Largest_Integer

整型常量

可以使计算机表示某个整数值，十进制、十六进制和八进制类型数据。八进制常量以 0 开头，后接 0 - 7 之间的数字（这里常常会设置一些考题，比如问：089 是什么数？千万别傻傻的写八进制数了，它是非法数）。十六进制常量以0x开头后跟多个 0 - 9之间的数字或 a - f （ A - F ）之间的字母

byte、short、int、long这四种类型是较为特殊的数据类型。byte 和 short类型主要应用于底层文件处理或在存储空间极其宝贵、又需要保存大型数组的特殊情况。long类型可表示数值较大的整数。int类型是最常用的，默认32位，若需要表示64位的long类型常量则在数字后加上大写字母 L 来区分

实型常量

两种表示形式：

（1）十进制数：由数字和小数点构成，且必须包含小数点；由于实数表示精度不同（单精度、双精度）。Java中默认实型常量为计算机中占64位的double类型，单精度数后面要加“f”或
“F”。双精度、多精度数后加“d”或“D”

（2）科学计数法：适用于数据过大或过小的情况，字母e或E前必须含有数字，后面的指数只能为整型数据

布尔常量

布尔型常量只有true和false两个值，分别表示真、假两种状态。它们不对应于任何整数值，仅用作逻辑条件的判断。我们在编码时直接使用 true和false 这两个单词，不要加引号。并且注意和C / C++语言不同的地方是，布尔型在Java中用关键字 boolean 单词全称，C/C++中用 bool 表示布尔型数据

1
2
3
boolean i; //建立布尔类型变量i
i=false;
i=true; //变量i的两种状态

字符串常量

字符串常量是用一对双引号括起来的一串字符。它和字符串常量在字符串仅有一个字符的情况下容易混淆：字符串常量包含转义字符 ‘\0’，其实是有两个字符。而字符常量就不一样了，无论字符串含有多少个字符，都是只占一个字符的空间大小

字符常量和null常量

字符常量就是单个ASCII字符用单引号括起来的形式。eg：’a’、’c’。null常量只有一个值，用null表示，表示对象的引用为空

1.3 运算符与表达式

在这个部分呢，来谈谈我的感受以及重点的部分，如果你是一名学生，不论是不是主修计算机专业，相信大部分的学校都会开设《C语言》这门课程（顺便问一问，学的怎么样啊？？），课程中的运算符与表达式章节和Java中的类型不能说的上一致，那简直就是完全一样呐

其实和上述内容一样，这些都是属于入门级别的内容。相信我，如果你学过甚至学会了《C语言》这门课程，Java中的这个章节完全可以略过（我是看完感觉没有什么不一样的地方，如有纰漏，实属小的太菜，还望各路大佬告知）

最有用的莫过于运算符的优先级了，这又让我想起了那些“变态”的题目：好多表达式 “ 掺和 ” 在一起，加上各种运算符连接，问你计算结果。仅仅一分的分值不说，最令人头大的是优先级分的也忒明显了，弄一会儿就绕进去了，反正我是很少做对（本人不才）。后来就死记硬背了一些重点的运算符优先级顺序才缓解了这样的窘境

附上一张我背记的表格（图片分页，还望xdm海涵）：

1.3.1 算术运算符

1
2
3
4
5
6
7
8
9
10
11
12
13
public class TestArithmeticOP {
    public static void main(String[] args){
        int n=1859,m;
        int a,b,c,d;
        d=n/1000;
        c=n/100%10;
        b=n/10%10;
        a=n%10;
        m=a*1000+b*100+c*10+d;
        System.out.println("原数据:n="+n);
        System.out.println("逆序数据:m="+m);
    }
}

1.3.2 逻辑运算符

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class TestLogicOP {
    public static void main(String[] args){
        boolean b1,b2=true,b3,b4;
        b1=!b2;
        System.out.println("逻辑值:b1="+b1+";"+"b2="+b2+";"+"b1&b2="+(b1&b2));
        int x=2,y=7;
        b3=x>y&&x++==y--; //逻辑短路问题 x和y的值并未发生改变
        System.out.println("逻辑值:b3="+b3+";"+"x="+x+";"+"y="+y);  
        x=2;
        y=7;
        b4=x>y&x++==y--;
        System.out.println("逻辑值:b4="+";"+b4+"x="+x+";"+"y="+y);
    }
}

//逻辑与预算符 && 逻辑或运算符 ||     条件与或  都会发生逻辑短路现象(仅查看一端操作数)

//& 与  | 或 布尔逻辑与或运算符  两端操作数都看

1.3.3 条件运算符

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class FindMaxMin {
    public static void main(String[] args){
        double d1=1.1,d2=-9.9,d3=96.9;
        double temp,max,min;
        //Max
        temp=d1>d2?d1:d2;
        max=temp>d3?temp:d3;
        //Min
        temp=d1<d2?d1:d2;
        min=temp<d3?temp:d3;
        System.out.println("max="+max);
        System.out.println("min="+min);
    }
}   //条件运算符(三目运算符) 使用

//本题也可以两个变量实现 Max和Min即可 同样使用三目运算符 

// Max=d1>d2?d1:d2;  Max=d3>Max?d3:Max;

1.3.4 位运算符

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public class TestBitOperation {
    public static void main(String[] args){
        byte b1=125,b2=38;
        int i1,i2,i3;
        i1=b1^b2;
        System.out.println("b1="+Integer.toString(b1,2));
        System.out.println("b2="+Integer.toString(b2,2));
        System.out.println("异或"+Integer.toString(i1,2));
        i1=i1^b2;
        System.out.println("(b1^b2)^b2="+Integer.toString(i1,2));
        i2=b1>>2;
        i3=b1<<2;
        System.out.println(b1+"右移两位等价与除4:"+i2);
        System.out.println(b1+"左移两位等价与乘4:"+i3);
    }
}

//逻辑类型运算符区别 & | ^ 根据其两端操作数不同承担不同的功能,当操作数为数值类型时,作为"位运算符";

//当操作数为布尔类型时做逻辑运算符 

// >> 不同于 >>>  前者移位时不包括符号位,后者移位连同符号位一并移位(负数操作完可能会影响其符号)

// ^ 异或 整型数据时,操作为双行列举 规则"相同为0,不同为1"

1.3.5 赋值运算符

1
2
3
4
5
6
7
8
9
10
11
12
public class Exchange {
    public static void main(String[] args){
        int a=5,b=7;
        System.out.println("a="+a+"\tb="+b);
        a+=b; 
        b-=a; 
        a-=b; 
        System.out.println("a="+a+"\tb="+b);
    }
}

//Java中允许连续赋值 z=x=y=2;  在Java中是允许的

1.3.6 表达式类型提升

1
2
3
4
5
6
7
8
9
10
11
12
13
//实现一个三位数各位数字相加
public class Sum {
    public static void main(String[] args){
        int n=123,a,b,c,Sum;
        a=n%10;  //依次 个 十 百位数字分离
        b=(n%100)/10;  //  /的优先级高于%,故加()
        c=n/100;
        Sum=a+b+c;
        System.out.println("AllSum("+n+")="+Sum);
    }
}

//对于计算顺序无法确定时,使用()进行区分层级
1
2
3
4
5
6
7
8
9
10
//求圆的面积
public class Circle_area {
    public static void main(String[] args){
        final float PI=3.14f; //常量
        float r=2.5f,area;
        area=PI*r*r;
        System.out.println("Area("+r+")="+area);
    }
}

1.4 语句及其控制结构

1.4.1 Java语句

Java中，程序实现各种各样功能的的原理是：使用类构建程序框架，使用方法实现类的功能，在方法中通过不同的语句结构控制程序流程实现，语句部分主要用例子来描述其使用方法

语句是指程序中的一个完整的执行单元，用于对数据进行加工处理、实现复杂功能。它是Java标识符的集合，由关键字、常量、变量、表达式共同组成。可分为说明性语句和操作性语句两种类型：

（1）说明性语句用来说明包和类的引入、类的声明、变量的声明；

（2）操作性语句包含表达式语句、复合语句、选择语句等；

表达式语句

表达式后接一个分号构成表达式语句，例如：赋值语句、自加自减语句以及方法调用语句等

1
2
3
double variable=100 ; //赋值
variable ++ ; //自增
System.out.println("Welcome to Java");//方法调用

复合语句

复合语句又称块（block）语句，由大括号 “｛｝” 括起来的部分称为语句块。执行复合语句时，实际上是执行该复合语句中所有语句。从语法上讲，无论大括号内有多少语句，都只被看成一条简单语句，多用于选择语句和循环语句中

1.4.2 选择语句

if···else语句

1
2
3
4
5
6
7
8
9
10
11
12
public class BlockDemo {
    public static void main(String[] args){
        boolean condition=false;
        if(condition){
            System.out.println("Success execute!");
        }
        else{
            System.out.println("error");    //此后包含一个换行符
            System.out.println("Waring");              //方法调用语句
        }
    }
}

switch语句

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import java.util.Scanner;

//需求:使用switch语句将week转换成对应英文字符串
public class Week {
    public static void main(String[] args){
        System.out.println("!Please Enter numbers in 0-6,it will transfer to corresponding Week!");
        Scanner input=new Scanner(System.in);
        int week=input.nextInt();
        switch (week) {
            case 0 -> System.out.println("Sunday");
            case 1 -> System.out.println("Monday");
            case 2 -> System.out.println("Tuesday");
            case 3 -> System.out.println("Wednesday");
            case 4 -> System.out.println("Thursday");
            case 5 -> System.out.println("Friday");
            case 6 -> System.out.println("Saturday");
            default -> System.out.println("Data error!!!");
        }        //Java中增强Switch语句
        input.close();
    }
}

//优化目的:实现提示用户数据输入,输出对应日期效果

1.4.3 循环语句

for循环语句

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
//求出个、十、百、千位数字的四次方的和等于该数本身的所有四位数
public class ForTest {
    public static void main(String[] args){
        int a,b,c,d;
        System.out.println("The Data That Meets The Conditions:");
        for(int n=1000;n<10000;n++){
            a=n/1000;//千位数字
            b=n/100%10;
            c=n/10%10;
            d=n%10;
            if(Math.pow(a,4)+Math.pow(b,4)+Math.pow(c,4)+Math.pow(d,4)==n){ //条件判断  Java中的次方写法
                System.out.println(n);
                System.out.println();
            }
        }
    }
}

//定式套用 顺次剥离各位数字（由高位到低位）

//a=n/1000;千位数字  b=n/100%10;  c=n/10%10;  d=n%10;

while循环语句

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
//求解 x=5时； x+x^2/2!+...+x^n/n!的值 要求x^n/n!的值<1.0 X 10^-8
public class WhileTest {
    public static void main(String[] args){
    int x=5;
    double sum=0,d=1.0;//因为有除法，故用小数 因为值<1.0 X 10^-8 所以d=1.0初值
    int n=1;
    while(d>1.e-8){ //注意计数法书写格式
        d*=x;
        d/=n;
        sum+=d;
        n++;
    }
    System.out.println("x="+x+";"+"Sum="+sum);
    }
}

//也可使用do-while实现

beak语句

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
import java.io.* ; //命令编译器载入java_installation/java/io路径下的所有类

//输入一个正整数,显示所有<=该数的所有素数
public class BreakTest2 {
    public static void main(String[] args) throws IOException {
        String str;
        BufferedReader buf;
        int k;
        buf = new BufferedReader(new InputStreamReader(System.in));
        System.out.println("Please enter an integer, and press Enter to find all prime numbers less " +
                "than or equal to the integer:");
        str = buf.readLine();
        k = Integer.parseInt(str);
        System.out.println("2 to" + " "+ k +" "+"all prime numbers between:");
        for (int i = 2; i <= k; i++) {
            if (isPrime(i))
                System.out.print(i + "\t");
        }
    }
    static boolean isPrime(int n) {    //方法实现
        boolean b = true;
        for (int k = 2; k <= n / 2; k++) {
            if (n % k == 0){
                b = false;
                break;
            }
        }
        return b;
    }
}

//Java中，如果给出一个完整的限定名(包名、类名），Java编译器就能快速定位到源代码/类

// Import语句就是用来提供一个合理的路径，使得编译器可以找到某个类

总结

我们在学习新知识的时候，不要总是抱有一步登天的想法，什么东西都想着要一下子掌握。这些看似细小的知识点很有可能会成为开发过程中你忽视的那一个。从每一个很小的例子开始，懵懂到知道，知道到理解，理解到上机，上机到掌握，逐步积累经验。相信自己，一定能学会，不要放弃。也正所谓 “ 不积跬步无以至千里，不积小流无以成江海 ”

Gitee/GitHub 上我的练习仓库：Gitee地址，GitHub地址，供大家学习参考，希望有所收获。码字不易，后面将会更新Java面向对象部分，如果帮到了您可以收藏学习，不要吝啬您的赞哦，您的支持将是我不断前行的动力！！