Java基础语法

新建空白项目

确保SDK与语言级别相对应，此处JDK版本为8，所以语言等级也为8。

之后依然正常创建class文件

1. 注释，标识符，关键字

（1）注释：书写注释，帮助自己看懂自己写的代码

单行注释：“ // ”加文字注释
```
//输出一个Hello,World !
```

多行注释：“ /* ”加注释加“ */ ”

/*
bababababababab
bababababababab
bababababababab
*/

文档注释：“ /** ”加注释加“ */ ”

/**
 * @Description Helloworld
 * @Author 朱飞鸿
 */

注释颜色更改

文件 > 设置 > 编辑器 > 配色方案 > Java > 注释 > 行注释 > 右侧更改

（2）标识符：java所有的组成部分都需要名字。类名、变量名以及方法名都被称为标识符。

①关键字

类名不可用关键词命名

public class HelloWorld {
    public static void main(String[] args) {
        //单行注释  //＋文字注释
        //输出一个Hello，World !

        String man = "飞鸿";

        System.out.println("Hello,World !");

“ public class HelloWorld { ”其中的HelloWorld就是一个类名也是文件的名字，
“ public static void main(String[] args) { ”其中的main就是一个方法名，
“ String man = "飞鸿"; ”就是定义了一个变量名man的值为" 飞鸿 "，

②标识符注意点

所有的标识符都应该以字母（A_Z或者az）、美元符（$）、或者下划线（_）开始
首字母之后可以是字母（A_Z或者az）、美元符（$）、或者下划线（_）或数字的任何字符组合
不能使用关键字作为变量名或方法名
标识符是大小写敏感的
合法标识举例：age、$salary、_value、__1_value
非法标识举例：123abc、-salary、#abc

可以使用中文命名，但是一般不建议，也不建议使用拼音

public class Demo01 {
    public static void main(String[] args) {

        String name = "名字";
        System.out.println(name);

        //大小写十分敏感
        String Man = "feihong";
        String man = "feihong";

        String Ahello = "feihong";
        String hello = "feihong";
        String $hello = "feihong";
        String _hello = "feihong";

        String _1= "feihong";

        //String 1hello = "com.feihong";
        //String #hello = "com.feihong";
        //String *hello = "com.feihong";
        //String _# = "com.feihong";

2. 数据类型

强类型语言：要求变量的使用严格符合规定，所有的变量都必须先定义后才能使用，安全性更高，速度慢一些，Java为一个强类型语言。

弱类型语言：Javasc

需要赋值为字符串，但赋的值为数字，无法输出

int行遇上相反情况，需要赋值为数字，但赋的值为字符串，无法输出

可以正常输出

（1）Java的数据类型分为两大类

（2）什么是字节

位（bit）：计算机内部数据储存的最小单位，11001100是一个八位二进制数。
字节（byte）：计算机中数据处理的基本单位，习惯上用大写B来表示。
1B（byte，字节）=8bit（位）
字符：计算机中使用的字母、数字、字和符号。
1bit表示1位，1Byte表示一个字节 1B=8b。
1024B=1KB，1024KB=1M，1024M=1G，1024G=1TB

（3）基本类型（primitive type）

数据类型
1. 整数类型：
  - byte占1个字节，范围：-128~127
  - short占2个字节，范围：-32768~32767
  - int占4个字节，范围：-2147483648~2147483647
  - long占8个字节，范围：-9223372036854775808~9223372036854775807
2. 浮点类型（小数）：
  - float占4个字节
  - double占8个字节
3. 字符类型char占2个字节（可以表示汉字）
boolean类型（是非）：占1位，其值只有true（是）和false（非）两个

除了八个基本类型（byte，short，int，long，float，double，char，boolean ），其他都为引用类型。

byte num2 = 200;//报错

byte最大值为127，赋值200超过其范围，无法赋值，需改为其他整数

（4）引用类型（reference type）

类
接口
数组

（5）整数拓展：进制

二进制：只有1和0表示，例如67=1000011，67/2=33余1，33/2=16余1，16/2=8余0，8/2=4余0，4/2=2余0，2/2=1余0，1/2=0余1，反方向排列余数得1000011。

八进制：有0~7表示，例如67=

十六进制：有0_9，AF（即10~15）表示，

public class Demo03 {
    public static void main(String[] args) {
        //整数拓展：进制
        //二进制以0b开头 十进制 八进制以0开头 十六进制以0x（小写X）开头
        int i = 10;
        int i2 = 0b10;//二进制0b
        int i3 = 010;//八进制0
        int i4 = 0x10;//十六进制0x

        System.out.println(i);//输出为10
        System.out.println(i2);//输出为2
        System.out.println(i3);//输出为8
        System.out.println(i4);//输出为16

（6）浮点数拓展：

//浮点数拓展：银行业务怎么表示？钱
//float
//double

float f = 0.1f;
double d = 1.0/10;
//都等于0.1

System.out.println(f==d);//输出为false，
System.out.println(f);//输出为0.1
System.out.println(d);//输出为0.1

f和d值都为0.1，但运行结果显示为false，即二者不相等，通过调试查看

调试：在代码前打一个点表示到此中断（点击代码前面即可）

shift加F9即可调试运行

可见f=0.1，d也为0.1，但二者却不相等

float d1 = 232323232323232323323f;
float d2 = d1 + 1;

System.out.println(d1==d2);//输出为true

而d1与d2不相等，却显示相等，可见浮点数存在问题

因为浮点树可以表现的字长是有限的、离散的，但有些东西相除是无限的，为了表示存在舍入误差这一步骤，结果只能是大约数，接近但不等于

所以不要用浮点数进行比较

银行业务要用一个数学工具类，BigDecimal。

（7）字符拓展：

//字符拓展

char c1 = 'a';
char c2 = '中';

System.out.println(c1);//输出为a
System.out.println((int)c1);//(int)强制转换可以把字符变成数字，输出为97
System.out.println(c2);//输出为中
System.out.println((int)c2);//输出为20013
//所有字符本质还是数字

所有字符本质还是数字

char类型涉及到编码，Unicode编码可以处理各种语言的文字，占2个字节，最多可以表示65536个字符，现在更多，其处理字符的方式就是其有一个编码表，每个字符对应一个数字，U0000~UFFFF

char c3 = '\u0061';

System.out.println(c3);//输出为a

举例：u0061就是小写a

//转义字符：
//\t:空格

System.out.println("hello\tworld");//输出为hello   world

//\n：换行

System.out.println("hello\nworld");//输出为hello
//                                        world

不同转义字符可实现不同功能，\t就可以实现空格，\n就可以实现换行，更多转义字符可自己探索

（8）布尔值拓展

//布尔值拓展
boolean flag = true;
if (flag==true){}
boolean flag1 = true;
if(flag1){}
//两个if意思是一样的，if(flag1)直接默认为true，不必再写==true，开始可以按上面写，熟练后按第二种写，保证代码精简易读

（9）对象先导（额外拓展）

String sa = new String( "hello world");
String sb = new String( "hello world");
System.out.println(sa==sb);//输出为false

String sc = "hello world";
String sd = "hello world";
System.out.println(sc==sd);//输出为true
//后面学对象  可以从内存分析

sa不等于sb，sc等于sd，后面学对象会再涉及。

3.类型转换

由于Java是强类型语言，所以进行有些运算的时候，需要用到类型转换。

由于所有字符本质都是数字，所以都可以进行运算。

运算中，不同类型的数据需要先转化为同一类型，然后进行运算

低 ------------------------------------------------> 高

byte，short，char，--> int --> long --> float --> double

运算的优先级按照容量（字节大小）从低到高排序，而float（32位）在long（64位）后面是因为小数的优先级大于整数。

（1）强制转换：由高到低转化

public class Demo004 {
    public static void main(String[] args) {

      int i = 128;
      byte b = i;//报错显示需要一个byte类型

如图想要把b赋予与i同样的值，直接等于发现抱错，显示需要一个byte类型，这种情况就需要强制转换了。

public class Demo004 {
    public static void main(String[] args) {

        //强制转换  （类型）变量名   高到低

        int i = 128;
        byte b = (byte)i;//内存溢出

        System.out.println(i);//输出为128
        System.out.println(b);//输出为-128

强制转换就是在值的前面加上（所需要的类型）即可

运行发现，输出的值不一样，因为byte类型最大值为127，赋予其128大于了其范围，这就涉及到了内存溢出的问题，转换成了一个其他的值，所以要避免内存溢出。

（2）自动转化：由低到高转化

不需要额外操作

（3）注意点

不能对布尔值进行转化

不能把对象类型转换为不相干的类型

//精度
System.out.println((int)23.7);//输出为23
System.out.println((int)-45.89f);//输出为-45

内存溢出问题或者精度问题

运算示例

char c = 'a';//a=97
int d = c+1;
System.out.println(d);//输出为98
System.out.println((char)d);//(char)强行转换为字符，输出为b

//操作比较大的时候，注意溢出问题
//JDK7新特性：数字之间可以用下划线分割
int money = 10_0000_0000;
int years = 20;
int total = money*years;

System.out.println(total);//输出为-1474836480,计算溢出了

操作比较大的时候，注意溢出问题

long total2 = money*years;
long total3 = money*((long)years);

System.out.println(total2);//依然为-1474836480,因为计算完之后才会转换为long类型，而转换之前已经存在问题了，所以不可以
System.out.println(total3);//因为在计算前先转换了，所以可以正确输出20000000000

4.变量，常量

（1）变量：可以变化的量

Java是一种强类型语言，每个变量都必须声明其类型。

Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域。

type(数据类型)  varName(变量名) [=value（值）]，可以用逗号隔开来声明多个同类型变量例如：int a=1,b=2,c=3;但不建议在一行里定义多个值，不方便查看。

注意事项：

每个变量都要有类型，可以是基本类型，也可以是引用类型。
变量名必须是符合合法标识符（详见新建空白项目1.（2））。
变量声明是一条完整的语句，因此每一个声明都必须以分号结束。

（2）变量作用域：

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

①类变量

②实例变量

public class Demo06 {
    //实例变量：在方法的外面，类的里面，从属于对象；如果不自行初始化，就会输出这个类型的默认值(所有的数值类型默认整数为0，小数为0.0；
    // 字符串为u0000，输出也为0；布尔值默认为false)。
    //除了基本类型，其他类型的默认值都是null（空的）；
    String name;
    int age;
    
    public static void main(String[] args) {
        
        //变量类型  变量名字 = new Demo06();
        Demo06 demo06 = new Demo06();//写出new Demo06后Alt加回车再回车，即可出现前半部分
        System.out.println(demo06.age);//输出为0
        System.out.println(demo06.name);//输出为null
    }
}

③局部变量

public class demo06 {
    //第一行即为类，类里面除了main一类的方法，还可定义属性（变量）

    //main方法
    public static void main(String[] args) {
        //局部变量：即在方法内的变量，大括号内终始
        int i = 1;
    }

    //其他方法
    public void add (){

        System.out.println(i);

    }
}

可以发现在main方法中定义的局部变量不能在其他方法中使用

（3）常量：初始化后不能再改变的值！不会变动的值！

常量可以理解为一种特殊的变量，它的值设定后，在程序运行的过程中不允许被改变。
常量名一般使用大写字符。

final 常量名=值;
final double PI=3.14;

（4）变量的命名规范

所有的变量、方法、类名做到见名知意
局部变量和类成员变量：第一个词首字母小写，接着后面所有的单词首字母大写；例：monthSalary
常量：全部大写字母，单词间加下划线_隔开：MAX_VALUE
类名：首字母大写，接着后面所有的单词也要首字母大写：GoodMan
方法名：第一个词首字母小写，接着后面所有的单词首字母大写：runRun()

5.运算符

运算优先级：尽量使用()，来提升需要优先运算的优先级

java支持以下运算符：

*算数运算符：

,- ,* ,/ ,%(模运算：即取余：11/5=2余1) ,++ ,-- ;

public class Demo01 {
    public static void main(String[] args) {
        //二元运算符，即两个数操作
        int a = 10;
        int b = 20;
        int c = 25;
        int d = 30;

        System.out.println(a+b);
        System.out.println(a-b);
        System.out.println(a*b);
        System.out.println((double)a/b);//10处于20等于0.5，但int为整数，四舍五入后输出为0，需要强制转换为一个浮点数
        System.out.println(c%a);//相当于c/a,25/10=2....5,输出结果为余数5

public class Demo04 {
    public static void main(String[] args) {
        //一元运算符：==(自增)，--（自减）
        int a=3;
        int b=a++;//a++或者++a都相当于 a=a+1
        //++在值的后面相当于执行了这行代码后，先给b赋值，再自增
        System.out.println(a);

        int c=++a;
        //++在值的前面相当于执行了这行代码前，先自增，再给c赋值
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);

        /*所以这里的代码逻辑为：
        第一行把3赋给了a
        第二行把a的值先赋给了b，再自增，此时a=4,b=3
        第三行，把a的值输出，结果为4
        第五行先自增，此时a的值为5，再把a的值赋给c，此时a=5,c=5
        第六行把a的值输出，结果为5
        第七行把b的值输出，结果为3
        第八行把c的值输出，结果为5
        */

        //幂运算 2^3 2*2*2 = 8,java无法这样表达，需要用到工具类
        double pow = Math.pow(2, 3);
        System.out.println(pow);//值为8

        double pow1 = Math.pow(3, 2);
        System.out.println(pow1);//值为9

*赋值运算符：

=（int a=10,即把10赋值给a）;

public class Demo02 {
    public static void main(String[] args) {
        long a = 123123123312133L;
        int b = 123;
        short c =10;
        byte d = 8;

        System.out.println(a+b+c+d);//只要有一个数为long，结果即为long
        System.out.println(b+c+d);//其他有没有int，都会为int
        System.out.println(c+d);

*关系运算符：

, < ,>= ,<= ,==（Java中表示相等关系） ,!=(不等于) ,instanceof;

package operator;

public class Demo03 {
    public static void main(String[] args) {
        //关系返回的结果为布尔值，只有正确或错误
        int a=10;
        int b=20;

        System.out.println(a>b);//结果为false
        System.out.println(a<b);//结果为true
        System.out.println(a==b);//结果为false
        System.out.println(a!=b);//结果为true

*逻辑运算符：

&& , || ,! ;

public class Demo05 {
    public static void main(String[] args) {
        //逻辑运算符：与（and）、或（or）、非(取反，非你即我)
        boolean a = true;
        boolean b = false;

        System.out.println("a&&b"+(a&&b));//逻辑与运算：两个变量都为真结果为true
        System.out.println("a||b"+(a||b));//逻辑或运算：两个变量有一个为真结果就为true
        System.out.println("!(a&&b)"+!(a&&b));//逻辑非运算；两个变量如果为真则为假，如果为假则为真

        //短路运算
        System.out.println("a&&b"+(b&&a));//括号内b在前，因为b本来就为false,按照逻辑会直接判断为false，并停止执行后半段

        int c=5;
        boolean d=(c<4)&&(c++<4);//如果正常执行，c的值输出应该为6

        System.out.println(d);
        System.out.println(c);//输出为5，Boolean运算中的c++没有执行

位运算符(了解)：

& ，| ，^ ,~ ,>> ,<< ,>>> ;

public class Demo06 {
    public static void main(String[] args) {
        /*
        A=0011 1100
        B=0000 1101

        A&B = 0000 1100 (A与B按位比较，都为1才为1)
        A|B = 0011 1101（A或B有1就为1）
        A^B = 0011 0001（A亦或B相同为0，否则为1）
        ~B = 1111 0010 （取反B，0为1，1为0）

        2*8=16怎么算最快：2*2*2*2*2
        <<(左移)，>>（右移）
         */
        System.out.println(2<<3);
        //2<<3意为，2左移3位
        //在二进制中，逢2进1，那2、4、8、16就呈现着如下规律
        //0：0000 0000
        //1：0000 0001
        //2：0000 0010
        //4：0000 0100
        //8：0000 1000
        //16：0001 0000
        //<<（左移）相当于*2，>>（右移）相当于/2，位运算涉及底层代码，效率极高！！！

条件运算符：

? ,: ;

public class Demo08 {
    public static void main(String[] args) {

        //x?y:z
        //如果x==true,则结果为y,否则结果为z;

        int score = 80;
        String type = score <60 ?"不及格":"及格";//作用等同于之后的if语句，虽然偷懒但必须掌握
        System.out.println(type);

        int score1 = 50;
        String a=score1 <60 ?"不及格":"及格";
        System.out.println(a);

扩展赋值运算符：

+= ,-= ,*= ,/= ;

public class Demo07 {
    public static void main(String[] args) {
        int a=10;
        int b=20;

        a+=b;//意为a=a+b,其他同理
        a-=b;//意为a=a-b

        System.out.println(a);

        //字符串连接符   +,只要加号左右一方出现String（字符串）类型，就会把另一方也改为字符串进行连接。
        System.out.println(a+b);//正常运算
        System.out.println("A"+a+b);//输出为A1020,没有运算，直接按字符串连接


        System.out.println(a+b+"A");//输出为30A,先运算，再按字符串连接

重点掌握上四个，第五个了解，下两个是偷懒的

6. 包机制，JavaDoc

（1）包机制：包的本质就是文件夹

package com.feihong.operator;//包，必须顶行

public class Demo02 {
    public static void main(String[] args) {
        long a = 123123123312133L;
        int b = 123;
        short c =10;
        byte d = 8;

        System.out.println(a+b+c+d);
        System.out.println(b+c+d);
        System.out.println(c+d);
    }
}

包语句的语法格式为：

package pkg1[.pkg2[.pkg3...]];

一般利用公司域名倒置作为包名；百度（www.baidu.com）>（com.baidu.www）
为了能够使用某一个包的成员，就需要在java程序中明确导入该包。使用“ import ”语句来导入。

import pkg1[.pkg2...].classname;

举例：

package com.feihong.operator;

import java.util.Date;//②java.util.Date就是Date所在的包位置。import行必须在package行的下面

public class Demo02 {
    public static void main(String[] args) {

        Date//①直接写是写不了的，报错会提示需要导入
    }
}

注意：

package com.feihong.operator;

import com.feihong.base.Demo02;//发现导入别的包的Demo02时，下一行本包的Demo02显示报错，所以注意尽量不要让包内文件重名

public class Demo02 {}//报错提醒已经被定义过了

package com.feihong.operator;

import com.feihong.base.*;//最后的.*是通配符，可以导入这个包下所有的类

public class Demo02 {}

规范书籍推荐：《阿里巴巴开发手册》

（2）JavaDoc

JavaDoc命令是用来的生产自己API文档的，与注释中的文档注释有关

JDK帮助文档网址：Overview (Java Platform SE 8 )

参数信息：

@author 作者名
@version 版本号
@since 指明需要最早使用的jdk版本
@param 参数名
@return 返回值情况
@throws 异常抛出情况

加在哪就是哪的注释

package com.feihong.base;

/**
 * @author feihong
 * @version 1.0
 * @since 1.8
 */
//这就加在了类上

public class Doc {

    String name;//为一个参数

    /**
     * 
     * @param name
     * @return
     */
    //这就加在了方法上
    //打出/**确定后自动生成了后面的文档注释，@param name表示参数的名字为name
    
    public String test(String name) {//为一个方法
        return name;
    }
}

public class Doc {

    String name;

    /**
     * @author feihong
     * @param name
     * @return
     * @throws Exception//这样就抛出了一个异常
     */
    public String test(String name) throws Exception{

        return name;
    }
}

Javadoc文件生成方式：

cmd生成：进入cmd 》进入doc所在文件》输入格式：javadoc （可加一些参数） Java文件

这其中的-encoding UTF-8 -charset UTF-8，是帮助更好显示中文的参数

Idea生成：工具》生成javadoc 》生成

解释下命令行实参填写-encoding utf-8-charset utf-8是为了防止生成JavaDoc时有乱码出现，

-encodingutf-8:源代码(包括JavaDoc注释的)为UTF-8编码

-charset utf-8:生成JavaDoc文档使用的字符集是UTF-8

基础一定要牢

posted on 2025-09-14 00:58 柴郡伊里奇阅读(5) 评论(0) 收藏举报

刷新页面返回顶部

公告

导航