Java基本语法

最新推荐文章于 2022-10-25 00:10:47 发布
最新推荐文章于 2022-10-25 00:10:47 发布
阅读量96 收藏
点赞数
分类专栏： 狂神说java学习笔记 文章标签： java jvm 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43521718/article/details/126648904
版权

Java基本语法

注释、标识符、关键字

写代码要写注释。不然过了一个小时，上帝都不知道这代码要干什么。

  • 单行注释
    //文字内容

  • 多行注释
    /**/，内部是文字内容。

  • 文档注释

    /**

    *@Descripion

    ​ */

    @变成了#064；在JavaDOS的时候会更详细的说明。

为了演示方便，新建一个空项目。
新建一个模块-》新建一个类-》项目模块-》选择当前版本对应的SDK和语言等级-》应用-》确定（搭建一个环境）

标识符与关键字

标识符

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

所有标识符都应该是以字母，$，或者下划线_ 开始的。

首字符后可以是字母，$，_，数字的任意符号组合。（一定不要随便使用#）

不能使用关键字做类名或方法名。

标识符是大小写敏感的。

可以使用中文命名，不过最好不要这么干。特别是用拼音……我敢打赌你不写中文注释一定会忘记这是个啥变量。

public class Hello {
    public static void main(String[] args) {
        //输出一个HelloWorld
        System.out.println("Hello,World!");
    /*这个是多行代码*/
        //有趣的代码注释
    }
}

关键字表

abstarctassertbooleanbreakbyte
casecatchcharclassconst
continuedefaultdodoubleelse
enumextendsfinalfinallyfloat
forgotoifimplementsimport
instanceofintinterfacelongnative
newpackageprivateprotectedpublic
returnstrictfpshortstaticsuper
switchsynchronizedthisthrowthrows
translienttryvoidvolatitewhile

数据类型

计算机语言大致分为两类：

  • 强类型语言（java，C++）
    要求变量的使用严格按照规定，所有变量都需要先定义后使用。
  • 弱类型语言（JavaScript）
    有自己的编辑器，有一定的规范化。

Java的数据类型分为两大类

  1. 基本类型（primitive type）

数值类型：

名称字节数表示范围
整数类型
byte1-128~127
short2-32768~32767
int4-2147483648~2147483647
long8
浮点类型
float4
double8
字符类型
char2字节
逻辑类型
boolean占1位true或false
public class Demo01 {
    public static void main(String[] args) {
        //八大基本数据类型
        int num1=10;    //最常用
        byte num2=20;
        short num3=30;
        long num4=30L;  //long类型要在后面加个L

        //浮点型
        float num5= 5.01F;   //float类型要在后面加个F
        double num6=3.141592653589;
        //字符
        char name='A';
        //字符串String不是关键词，string是一个类
       //布尔值
        boolean flag=false;


    }

}
  1. 引用类型（reference type）

  • 类

  • 接口

  • 数组

非基本数据类型都是引用类型。

拓展：什么是字节？

位（bit）是计算机内部数据存储的最小单位。举个例子，11001100是一个八位二进制数。

字节（byte）是计算机中数据处理的基本单位，习惯上用B表示。

1B=8 bit；1024B=1KB；1024KB=1M；1024M=1G

字符：是指计算机中使用的字母，数字和符号。

电脑32位和64位指的是电脑寻址的能力。32位指的是处理器一次能处理的最大位数。最大寻址空间是2^32=4G左右。

public class Demo2 {
    private static String original;

    public static void main(String[] args) {
        //整数拓展：进制 二进制0b 十进制 八进制0 十六进制0X
        int i1=10;
        int i2=010;
        int i3=0X10;
        int i4=0b10;

        System.out.println(i1);
        System.out.println(i2);
        System.out.println(i3);
        System.out.println(i4);
        System.out.println("=================");
        /**
         * 浮点数扩展
         * 银行业务怎么表示？
         * 不要用float double来计算。
         * 浮点数是有限的、离散的。有舍入误差，接近但不等于。最好完全不使用浮点数进行比较。
         * BigDecimal 数学工具类
         */
        float f=0.1f;
        double d=1.0/10;
        //都是0.1
        System.out.println(f==d);
        System.out.println(f);
        System.out.println(d);
        float d1=23134456f;
        float d2=d1+1;
        System.out.println(d1==d2);
        System.out.println("=================");

        /**
         * 字符拓展
         * 所有的字符本质上还是数字
         * Unicode 2字节 65536
         * 最早期的Excel最长 2^16 =65536
         * U0000-UFFFF
         * 转义字符
         * \t  \n
         */
        char c1='a';
        char c2='中';
        System.out.println(c1);
        System.out.println((int)c1);    //强制类型转换
        System.out.println(c2);
        System.out.println((int)c2);
        char c3='\u0061';
        System.out.println(c3);

        System.out.println("Hello\nWorld");

        System.out.println("===============");


        /**String sa=new String(original:"hello world");
        String sb=new String(original:"hello world");
        System.out.println(sa==sb);*/

        String s1= "hello world";
        String sd= "hello world";
        System.out.println(s1==sd);
        //对象，从内存级别分析
        //布尔值的扩展
        boolean flag=true;
        int i=1;
        if(flag==true)
            i++;
        if(flag)
            i++;
        //二者是相同的。代码要简洁易懂。
    }
}

类型转换

运算中，不同类型的数据先转换为同一类型，然后进行运算。

类型转换从低到高进行。

public class Demo03 {
    public static void main(String[] args) {
        int i=128;
        byte b=(byte)i;//内存溢出
        System.out.println(i);
        System.out.println(b);
    }
}

  • 强制类型转换
    （类型）变量名 高——>低

  • 自动类型转换
    低——>高

tips：

  1. 不能对布尔类型进行转化
  2. 不能把对象类型转换为不相干的类型
  3. 高容量向低容量转化需要强制转换
  4. 转换的时候可能出现内存溢出或精度问题。
public class Demo03 {
    public static void main(String[] args) {
        System.out.println((int)23.7);  //23
        System.out.println((int)-45.89f);   //-45

		char c='a';
       	int d=c+1;
        System.out.println(d);
        System.out.println((char)d);
    }
}

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


public class Demo03 {
    public static void main(String[] args) {
       //jdk7的新特性，数字之间可以用下划线划分。
        int money=10_0000_0000;
        int years=20;
        int total=money*years;//-1474836480,计算的时候溢出了
        long total2=money*years;
        System.out.println(total);
        System.out.println(total2);//默认是int，转换之前已经溢出了。
        long total3=money*((long)years);//先把一个数转化为long
        System.out.println(total3);
    }
}

类也按照这样的格式进行类型转换。

变量、常量

变量是可以变化的量。
每个变量必须声明其类型。
变量是程序中最基本的存储单元。

type varName [=value] [{, varName[=value]}]；

数据类型 变量名=值；
可以使用逗号隔开声明多个同类型变量。

每个变量都有类型，可以是基本类型，可以是引用类型。
变量名必须是合法的标识符
变量声明是一条完整的语句，声明完毕必须用；结尾。
最好一次声明一个变量

变量的作用域

类变量：static，在类内。
实例变量：没有关键词
局部变量：在方法内

public class Demo04 {
    //属性：变量
    static{
        //代码块，这里的变量优先级很高
    }
      //类变量static
      static double salary=2500;
    //实例变量：从属于对象数值类型初始值0 boolean初始值 false 除了基本类型其余初始值都是null
    String str="Hello World!";
    String name;
    int age;
    //main方法
    public static void main(String[] args){
        //局部变量：生命周期在方法内，必须声明和初始化值。
        int i=0;
        System.out.println(i);
        //变量类型 变量名字=new Demo04();
        Demo04 demo04=new Demo04();
        System.out.println(demo04.age);
        System.out.println(demo04.name);
        System.out.println(salary);
    }
  
    //其他方法
    public void add(){
        System.out.println(i);
    }
}

常量Constant：初始化后不能改变的值

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

常量名一般使用大写字母。

public class Demo05{
static final double PI=3.14;//一个静态常量
//修饰符不存在先后顺序
public static void main(String[] args)
System.out.println(PI);
}

变量的命名规范

所有方法、类名、变量：见名知意

类成员变量、局部变量、方法名：首字母小写，驼峰原则。除了第一个单词意外剩下的单词首字母都大写。

常量：大写字母和下划线

类名：首字母大写，驼峰原则

运算符

基本运算符

算数运算符： + - * / % ++ –

赋值运算符： =

关系运算符： > < >= <= == != instance of

逻辑运算符： && || !

位运算符： & | ^ ~ >> << >>>

条件运算符： ? :

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

package operator;
public class Demo01 {
    public static void main(String[] args) {
        //二元运算符
        //Ctrl+D 复制当前行倒下一行
        int a=10;
        int b=20;
        int c=25;
        int d=25;
        System.out.println(a+b);
        System.out.println(a-b);
        System.out.println(a*b);
        System.out.println(a/(double)b);

    }
}

结果：

30
-10
200
0.5

30
-10
200
0

---

123123123123264
141
18



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

        System.out.println(a+b+c+d);//long
        System.out.println(b+c+d);//int
        System.out.println(c+d);//int
        //有long类型结果为long，除此之外都为int类型 cast==转换
    }
}

结果：

false
true
false

```java
package operator;
public class Demo03 {
    public static void main(String[] args) {
        //关系运算符返回的结果：正确，错误 布尔值
        int a=10;
        int b=20;
        System.out.println(a>b);
        System.out.println(a<b);
        System.out.println(a==b);
    }
}

结果：

1
false
true
false

package operator;
public class Demo03 {
    public static void main(String[] args) {
        //关系运算符返回的结果：正确，错误 布尔值
        //if
        int a = 10;
        int b = 20;
        int c = 21;

        System.out.println(c%a);

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

结果：

5
5
3
3
5
5

4
5
5
3
3
5
5


package operator;
public class Demo04 {
    public static void main(String[] args) {
        // ++ -- 自增，自减（一元运算符）
        int a =3;
        
        int b=a++;//执行完这行代码前，先给B赋值，接着自增
        //a=a+1,
        System.out.println(a);
        //a=a+1
        int c=++a;//执行这行代码后，先自增

        System.out.println(a);
        System.out.println(a);
        System.out.println(b);
        System.out.println(b);
        System.out.println(c);
        System.out.println(c);

    }
}

结果：

double pow=Math.pow(2,3);
System.out.println(pow);

很多运算都会使用一些工具类来做。

package operator;
//逻辑运算符
public class Demo05 {
    public static void main(String[] args) {
        //与或非(取反）
        boolean a = true;
        boolean b = false;

        System.out.println("a&&b: "+(a&&b));//逻辑与 同真为真
        System.out.println("a||b: "+(a||b));//逻辑与 一真为真
        System.out.println("!(a&&b): "+(!(a&&b)));//是真为假，是假为真

        //短路运算，前假，直接输出false，后面的不执行
        int c = 5;
        boolean d = (c<4)&&(c++<4);
        System.out.println(d);
        System.out.println(c);
    }
}

结果：

a&&b: false
a||b: true
!(a&&b): true
false
5

进程已结束,退出代码0

package operator;
public class Demo06 {
    public static void main(String[] args) {
        /**
         * A=0011 1100
         * B=0000 1101
         *
         * A&B（按位比较，同1为1）0000 1100
         * A|B（按位比较，有1为1）0011 1101
         * A^B（按位比较，相同为0）0011 0001
         * ~B 1111 0010
         *
         *  2*8怎样运算最快？
         *  2*8=16 2*2*2*2
         *  <<左移 *2
         *  >>右移 /2
         */
        System.out.println(2<<3);
    }
}

结果：

16

位运算效率极高。

package operator;
public class Demo07 {
    public static void main(String[] args) {
        int a=10;
        int b=20;
        a+=b;
        System.out.println(a);
        //字符串连接符 + 两侧出现string类型，输出结果为string类型
        System.out.println(a+b);
        System.out.println(""+a+b);
    }

30
50
3020

package operator;
public class Demo07 {
    public static void main(String[] args) {
        int a=10;
        int b=20;
        //a+=b;
        //System.out.println(a);
        //字符串连接符 + 两侧出现string类型，操作数转换为string类型进行连接
        System.out.println(a+b);
        System.out.println(""+a+b);
        System.out.println(a+b+"");
    }
}

30
1020
30

package operator;
public class Demo08 {
    //三元运算符
    public static void main(String[] args) {
        // x?y:z
        // 如果x==true,输出y;x==false,z
        int score=80;
       String type= score<60?"不及格":"及格";
        System.out.println(type);
    }
}

及格

包机制

包的本质是文件夹。
一般利用公司域名倒置作为包名。例如：com.kuangstudy.blog
package必须放在最上面。
import导入。
尽量不要让包的名字重复。
Ctrl+鼠标右键可以跳转包
alt+enter 自动纠错

package pkg1[. pkg2[. pkg3…]];
import package1[. package2[. package3…]];

//导入这个包下所有的类
import com.kuang.base.*;

课外阅读：《阿里巴巴Java开发手册》

JavaDoc

生成一个API文档。Java SE API-》8-》
[在线API帮助文档][https://docs.oracle.com/javase/8/docs/api/]
参数信息

新建Doc类

package com.star_line;
/**
 * @author Star_Line
 * @version 1.0
 * @since 1.8
 */
public class Doc {
    String name;

    /**
     * @author Star_Line
     * @param name
     * @return
     * @throws Exception
     */
    public String test(String name) throws Exception{
        return name;
    }
}

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

打开代码所在的文件夹，输入CMD打开命令行窗口。输入javadoc -encoding utf-8 -charset utf-8 Doc.java，回车键生成，点击index.HTML查看。
javadoc （CMD命令行）+参数+java文件名

作业：学会查找使用IDEA生产JavaDoc文档 （面向百度编程）

  1. 新建一个文件夹，存放Javadoc文档。
  2. 打开IDEA选择要生成文档的代码。
  3. 工具——生成JavaDoc——输出目录——选择文件夹
  4. 在locale输入zh_CN，在下方框中输入 -encoding utf-8 -charset utf-8
  5. 点击OK，打开JavaDoc文件夹。点击index.HTML可以查看生成的API文档。

基础部分每天都在用，记牢。

star_line！
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java基础语法.docx
05-13
Java基础语法的word版，md版本图片可能加载不出来，这个有全部的效果图，配合视频看效率更快——b站“狂神说Java”
Java基础语法
小叶
04-17 4954
一、 基础语法 Java大小写敏感。比如HelloWorld和Helloworld是不一样的。 包名 Package——公司、组织、个人的域名的反向，一般是英文字母。英文字母必须是小写。 类名（ClassName）采用大驼峰命名法，例如：StudentName。Java源文件的文件名必须和文件中公共（public）类名称一样。方法名采用小驼峰命名法，例如：studentName。 二、 关键字 关键字中所有字母都为小写。关键字不能用作变量名，方法名，类名，包名和参数。 三、 基本数据类型 基本数据类型分为
Java入门之~Java基础语法
Ara-追着风跑
03-12 6905
Java入门之基础语法篇，收藏学起来
JAVA基础语法
m0_64253261的博客
10-25 2391
JAVA基础语法
java基础语法（精简版）
qq_52857122的博客
03-21 4889
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录 前言 一、运算符 算数运算符 赋值运算符 关系运算符（比较运算符） 逻辑运算符 三元运算符 二、条件控制语句 switch语句 流程控制语句 if语句 三、循环 四、随机数 五、数组 六、二维数组 总结 一、运算符 1、算数运算符 首先知道运算符和表达式： ·运算符：对常量或者进行操作的符号。 ...
Java基础语法)教案
04-05
Java基础语法)教案Java开发环境搭建，HelloWorld案例，注释、关键字、标识符以及Java中的数据，但是难度都相对较低，大家只需要下去多加练习，掌握肯定没问题。 关于前两大块内容，Java开发环境待见和HelloWorld案例...
Java基础语法.zip
04-10
Java基础语法.zip 小白入门
Java基本语法大全(全).ppt
03-23
Java基本语法大全
Java 基本语法
11-03
Java语言是一种严格的“类型化”语言。...Java语言提供了八种基本类型。六种数字类型（四个整数型，两个浮点型），一种字符类型，还有一种布尔型。Java另外还提供大数字对象，但它不是Java的数据类型。
Java基础语法.pdf
07-13
Java基础语法.pdf
java基础语法
11-30
针对java基础语法的一些笔记,方便大家学习,其中文档中绿色部分,是我学习java编程思想后补充的心得体会
Java基础语法.md
05-05
java零基础入门教学——基础语法，java基础的基础，适合任何人观看，无需掌握很多基础知识，全分段基础，从零开始也不会迷路
java基本语法.xmind
08-08
自己总结的java基础的笔记，绘制了详细的思维导图，每个思维导图中均有详细的博文解释，方便大家学习和理解，免费分享给大家。适合java的爱好者和学习者
02.Java基础语法
最新发布
08-09
Java基础语法 类型转换 原因：开发中会存在不同类型的变量或者数据赋值给其他类型的变量，也存在不同类型的数据一起运算，其结果类型要确定下来 自动类型转换 原理：小范围类型的变量可以直接赋值给大范围...
JAVA基础语法格式入门
12-26
JAVA基础语法格式入门JAVA基础语法格式入门JAVA基础语法格式入门JAVA基础语法格式入门JAVA基础语法格式入门JAVA基础语法格式入门JAVA基础语法格式入门JAVA基础语法格式入门JAVA基础语法格式入门JAVA基础语法格式入门...
Java基本语法.doc
04-21
Java基本语法
java基本语法学习重点
05-28
Java 基本语法是学习 Java 的重要基础，以下是 Java 基本语法的一些重点： 1. 数据类型 Java 中有8种基本数据类型和引用数据类型，需要了解它们的特点和使用方法，例如数据类型的取值范围、默认值等。 2. 变量 ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值