Java SE基础语法知识点（C语言快速转Java）

1、Java程序基础

1.1 JDK和JRD

JDK=JRE+Java开发工具；

JRD=JVM+Java核心类库；

1.2 命令行操作

cd md创建文件目录；

cd rd删除；

cd del删文件；

cd ..返回上一级；

cd /跳转目录；

1.3 pubilic+class

类名-->与文件名一致；

1.4 字节码文件

编译后生成字节码文件（.class）有几个类生成几个；

2、标识符

2.1 标识符的组成

数字、字母、下划线、美元符号（可以是中文），

与C语言相同首字符不能以数字开头；

与C语言相比，标识符的组成多了一个美元符号；

2.2 遵守驼峰命名方式

e.g. SytemService、UserService；

2.3 类名、接口名：

首字母大写，后面每个单词首字母大写；

2.4 变量名、方法名：

首字母小写，后面每个单词首字母大写；

2.5 常量名：

全部大写；

//与C语言的常量不同字面值（数据）看见字知其数据；

e.g.10.100，3.14，"abc",'a',ture、false（布尔型）；

3、关键字

关键字要小写

public、class、static、void......

4、变量与常量

4.1 变量

Java中变量必须声明再赋值才能访问（否则内存未开辟出来）；

变量必须初始化；

4.2 常量

常量有final关键字修饰；

5、boolean类型

5.1 布尔类型的值

boolean类型只有ture false 没有其他值；

5.2 布尔类型占用的字节数

boolen类型只占用1个字节；

5.3 布尔类型的底层表示和定义

不像C语言有0、1表示假和真；

底层false为0，ture为1；

定义：boolean i = true；

6、byte类型

byte类型表示8位带符号的二进制数；

7、char类型

7.1 char类型占有字节数

char类型在java中占2个字节；

7.2 char类型与short类型

char和short可表示的种类数量相同，但char可取更大的正整数；

8、float类型与double类型

java中无float类型，定义float类型时，在浮点数后**+f**；

否则认为是double类型，编译失败；

9、类型转换

1、布尔类型无法强制转换；

2、Java：高精度赋值给低精度时需要强制转换，否则编译错误,显示不兼容的类型，高精度到低精度会造成损失精度；e.g.long-->int

3、C语言：高精度赋值给低精度时，会有精度缺失，但不会造成编译失败；

4、Java和C语言：低精度赋值给高精度（小容量-->大容量） 自动转换，不存在精度损失；e.g. int-->long

5、当整数字面值未超过byte、short、char的取值范围可以直接赋值给byte、short、char；

6、byte、short、char混合运算时，先各自转换成int；

byte b=10;
b=b+5;
System.out.println(b);

编译报错，因为（b+5自动转换成了int类型，所以要想通过编译，需要加强制转换）

byte b=10;
b=(byte)(b+5);
System.out.println(b);

7、多种数据类型混合运算时，先转换成容量最大的类型；

8、long类型在后面+**'L'**，long 10L，L用来判断是否为long类型；

9、float表示离散、有限、舍入误差、大约、接近不等于、0.1！=0.1，c=c+1；

需要完全避免用浮点数比较大小；

10、

int i = 128；
byte b=(byte) i;

输出为-127（因为有溢出）；

11、JDK新特性

数字之间可以用下划线分隔，更清楚分辨位数;

e.g.10_0000_0000

10、类的定义

10.1 语法结构

[修饰符列表] class 类名{

}

String不属于基本数据类型，是一个字符串类型，也是一个引用类型；

引用数据类型还包括：类，接口，数组；

String是SUN在JavaSE中提供的字符串类型；

String.class字节码文件；

重点：

1、属性通常是采用一个变量的形式来完成定义的；

2、在类体当中，方法体之外定义的变量被称为"成员变量"，成员变量没有赋值，系统赋默认值：一切向0看齐；

10.2 基本数据类型

byte、short、int、long、float、double、boolean、char；

10.3 引用数据类型

String.class SUN提供的；

System.class SUN提供的；

Student.class 程序员自定义的(是一个类，类型，引用数据类型)；

11、逻辑运算符（布尔运算符）

& 逻辑与

| 逻辑或

！逻辑非（取反）

^ 逻辑异或（两边的算子只要不一样，结果就是ture）

&& 短路与

|| 短路或

1、逻辑运算符要求两边的算子都是布尔类型，并且逻辑运算符最终的运算结果也是一个布尔类型；

2、“短路与（或）”和“逻辑与（或）”最终的结果相同，只不过“短路与（或）”存在短路现象

11.1 逻辑与&

&左边无论是true还是flase都会计算右边；

int x=10;
int y=8;
System.out.println(x < y & ++x < y);
System.out.println(x);

运行结果为11

11.2 短路与&&

&&左边若为false则直接短路，右边不再计算（短路现象）；

int x=10;
int y=8;
System.out.println(x < y && ++x < y);
System.out.println(x);

运行结果为10

从某个角度来看，短路与更智能，效率更高；

12、运算符

12.1 赋值运算符

+=、-=、*=、/=、%=；

byte、short、char混合运算时，先各自转换成int；

byte b=10;
b=b+5;
System.out.println(b);

编译报错，（b+5自动转换成了int类型，所以要想通过编译，需要加强制转换或者使用b+=5）

byte b=10;
b=(byte)(b+5);
b+=5;
System.out.println(b);

以上述例子为例

b+=5和b=b+5并不等同；

b+=5与b=(byte)(b+5)是等同的；

结论:

扩展类的赋值运算符不改变运算结果类型，假设最初这个变量的类型是byte类型，无论怎么进行追加或追减，最终该变量的数据类型还是byte类型，但有可能会损失；

12.2 字符串连接运算符

关于java中"+"运算符：

1、+运算符在java语言当中有两个作用：

*加法运算，求和；

*字符串的连接运算；

2、"+"两边的数据都是数字的话一定是加法运算；

3、"+"两边的数据只要有一个数据是字符串，一定会进行字符串的连接运算，连接运算之后的结果还是一个字符串类型；

静态输出

e.g.System.out.println(10+20);//30

System.out.println(10+20+"30");//"3030"

System.out.println(10+(20+"30");//"102030"

System.out.println("10+20="+a+b);

"10+20="是字符串；

"10+20="+a先运算字符串+a等于个字符串"10+20=10"；

"10+20="+a+b再运算**+b**等于个字符串"10+20=1020"；

System.out.println("10+20="+(a+b))；

此时先运算（a+b)=30，在进行字符串"10+20="+30="10+20=30"；

动态输出

System.out.println(a+"+"+b+"="+(a+b));

12.3 三元运算符/三目运算符/条件运算符

e.g.1

10，'男'不是一个完整的java语句；

boolean sex=false;
sex ? '男' : '女';

编译会报错；

修改如下：

boolean sex=false;
char c = sex ? '男' : '女';
System.out.println(c);

e.g.2

boolean sex=false;
char c = sex ? "男" : '女';
System.out.println(c);

编译报错，类型不兼容，但可以直接用

System.out.println(sex ? "男" : '女');

13、用户控制端输入

第一步：创建键盘扫描器对象

java.util.scanner s = new java.util.Scanner(System.in);

第二步：调用Scanner对象的next()方法开始接收用户键盘输入

敲完回车键键入的信息会自动赋值给标识符

String userInputContent = s.next();

【以字符串的形式接收】

int num = s.nextInt();

【以整型的形式接收】

//标识符的命名规范：见名知意

13.1 Scanner类中的方法

优点一: 可以获取键盘输入的字符串；
优点二: 有现成的获取int,float等类型数据，非常强大，也非常方便；

Scanner s = new Scanner(System.in); 
System.out.println("ScannerTest, Please Enter Name:"); 
String name = sc.nextLine();  //读取字符串型输入

Scanner s = new Scanner(System.in); 
System.out.println("ScannerTest, Please Enter Age:"); 
int age = sc.nextInt();    //读取整型输入

Scanner s = new Scanner(System.in); 
System.out.println("ScannerTest, Please Enter Salary:"); 
float salary = sc.nextFloat(); //读取float型输入

Scanner s = new Scanner(System.in); System.out.println("Your Information is as below:"); 
System.out.println("Name:" + name +"\n" + "Age:"+age + "\n"+"Salary:"+salary);

13.2 System.in和System.out方法

缺点一: 该方法能获取从键盘输入的字符，但只能针对一个字符的获取
缺点二: 获取的只是char类型的。如果想获得int,float等类型的输入,比较麻烦。

try{ 
  System.out.print("Enter a Char:"); 
  char i = (char)System.in.read(); 
  System.out.println("Yout Enter Char is:" + i); 
} 
catch(IOException e){ 
  e.printStackTrace(); 
}

13.3 InputStreamReader和BufferedReader方法

优点: 可以获取键盘输入的字符串
缺点: 如何要获取的是int,float等类型的仍然需要转换

System.out.println("ReadTest, Please Enter Data:"); 
InputStreamReader is = new InputStreamReader(System.in); //new构造InputStreamReader对象 
BufferedReader br = new BufferedReader(is); //拿构造的方法传到BufferedReader中 
try{ //该方法中有个IOExcepiton需要捕获 
  String name = br.readLine(); 
  System.out.println("ReadTest Output:" + name); 
} 
catch(IOException e){ 
  e.printStackTrace(); 
}

13.4 nextLine( )和next( )的区别

**nextLine( )**方法返回的是Enter键之前的所有字符，它是可以得到带空格的字符串的。 **next( )**会自动消去有效字符前的空格，只返回输入的字符，不能得到带空格的字符串。

14、方法

14.1 方法的定义，语法结构

[修饰符列表] 返回值类型方法名（形式参数列表）{

方法体；

}

注意：

1）修饰符列表可选项，不是必须的，目前统一写成public static；

2）方法内的修饰符列表当中有static关键字时，调用方法：类名.方法名（实际参数列表）；当方法在该类中时，"类名."可以省略；

3）方法名：首字母小写，后面每个字母大写，遵循驼峰规则；

4）建议一个源文件当中只定义一个class，比较清晰；

14.2 方法在执行过程中，JVM内存的分配和变化

14.2.1 方法的定义和执行：

方法只定义，不调用是不会执行的，并且在JVM中也不会给该方法分配"运行所属"的内存空间；只有调用的时候才会分配所属的内空间；

14.2.2 JVM内存划分上主要的内存空间：

方法区内存、堆内存、栈内存（还有其他的内存空间）；

14.2.3 栈数据结构：

*栈：stack，是一种数据结构；

*数据结构是数据的存储形态；

*常见的数据结构：数组、队列、栈、链表、二叉树、哈希表/散列表；

14.2.4 方法代码文件的存储位置，内存的分配位置：

1）方法代码片段属于**.class字节码文件的一部分，字节码文件在类的加载的时候，将其放到了方法区当中。所以JVM中的三块主要的内存空间中方法区内存**最先有数据。存在了代码片段；

2）代码片段虽然在方法区当中只要一份，但是可以重复调用。每一次调用这个方法的时候，需要给该方法分配独立的活动场所，在栈内存中分配【栈内存中分配方法运行的所属空间】；

3）方法在调用的瞬间会给该方法分配独立的内存空间，在栈中发生压栈动作，方法执行结束之后，给该方法分配独立的内存空间全部释放，此时发生弹栈动作。

压栈：给方法分配内存；

弹栈：释放该方法的内存空间；

4）局部变量在在“方法体”中声明，在栈中存储，运行时在栈中分配；

e.g.下列程序模型就是一个压栈、弹栈的过程；

main begin
m1 begin
m2 begin
m3 begin
m3 over
m2 over
m3 over
main over

14.3 栈内存的特点

1）栈帧永远指向栈顶元素

2）栈顶元素处于活跃状态，其他元素静止

3）术语：压栈/入栈/push

弹栈/出栈/pop

4）栈数据结构存储数据的特点：

先进后出；

后进先出；

15、方法执行内存分析

public class MethodTest01
{
    public static void main(String[] args)
    {
        int a = 10;
        int b = 20;
        int restValue = sumInt(a,b);
        System.out.println("retValue = "+ retvalue);
    }
    public ststic int sumInt(int i,int j)
    {
        int result = i + j;
        int num = 3;
        int reValue = divide (result,num);
        return retValue;
    }
    public static int divide (int x,int y)
    {
        int z = x / y;
        return z;
    }
}

16、方法重载（overload）

优点：

功能不相同但相似，像是在使用同一个方法一样，程序员编写代码更加方便，也不需要记忆更多的方法名，代码更美观；

（javascript不支持方法重载机制）

public class MethodTest01
{
    public static void main(String[] args)
    {
        System.out.println(sum(1,2));
        System.out.println(sum(1.0,2.0));
        System.out.println(sum(1L,2L));
    }
    public static int sum(int a,int b)
    {
        return a + b;
    }
     public static long sum(long a,long b)
    {
        return a + b;
    }
     public static double sum(double a,double b)
    {
        return a + b;
    }
}

参数的类型不同，对应调用的方法也不同。此时区分方法不再依靠方法名了，依靠的是实参的数据类型。

16.1 什么时候考虑使用方法重载？

*功能相似的时候，尽可能让方法名相同；

【功能不同/不相似的时候，尽可能让方法名不同】；

16.2 构成方法重载的条件

1）在同一个类中

2）方法名相同

3）参数列表不同

（数量不同、顺序不同、类型不同）

16.3 方法重载的影响因素

1）方法重载和方法名+参数列表有关；

2）方法重载和返回值类型无关；

3）方法重载和修饰符列表无关；

16.4 方法重载的应用

用户自定义封装一段代码，使得在使用时更加便捷快速调用；

public class helloworld
{
     public static void main(String[] args)
    {
         U.v(2.0);
     }
}
class U
{
    public static void v(long b){
        System.out.println(b);
    }
    public static void v(double b){
        System.out.println(b);
    }
    public static void v(short b){
        System.out.println(b);
    }
     public static void v(char b){
        System.out.println(b);
    }
     public static void v(String b){
        System.out.println(b);
    }
     public static void v(byte b){
        System.out.println(b);
    }
}

17、方法递归

缺点：

耗费栈内存，调用一次方法栈内存就会新分配一块所属的内存空间；

当没有结束条件时，栈内存溢出错误，错误无法挽回，只要一个结果，就是JVM停止工作；

标签： java 开发语言后端

本文转载自: https://blog.csdn.net/m0_61163395/article/details/122264457
版权归原作者 80岁的程序猿 所有，如有侵权，请联系我们删除。

Java SE基础语法知识点 （C语言快速转Java）