Java基础语法

最新推荐文章于 2024-09-27 00:45:01 发布

HuangChunLei_

最新推荐文章于 2024-09-27 00:45:01 发布

阅读量120

点赞数

分类专栏： Java 文章标签： java

本文链接：https://blog.csdn.net/HuangChunLei_/article/details/118598569

版权

Java 专栏收录该内容

20 篇文章 2 订阅

订阅专栏

一、注释、标识符、关键字

1. 注释

单行注释
多行注释
文档注释

public class HelloWord {
    public static void main(String[] args) {
        //单行注释：注释一行文字  //
        //输出HelloWorld
        System.out.println("Hello,world!");
        /*
            多行注释：可以注释一段文字
         */

        /**
         *文档注释
         **/
    }
}

2. 关键字

		关键字
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

3. 标识符

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

所有的标识符都应该以字母（A-Z或者a-z）、美元符（$）、或者下划线（_）开始
首字符之后可以是字母（A-Z或者a-z）、美元（$）、下划线（_）或数字的任何字符组合
不能使用关键字作为变量名或方法名
标识符是大小写敏感的
合法标识符举例：age、$salary、_value、__1_value
非合法标识符举例：123abc、-salary、#abc
可以使用中文命名，但一般不建议这样去使用，也不建议使用拼音，很low

二、数据类型

强类型语言
- 要求变量的使用要严格符合规定，所有变量都必须先定义后才能使用
弱类型语言
Java的数据类型分为两大类
- 基本类型（primitive type）
  - 数值类型
    - 整数类型
      - byte（范围-128到127）
      - short（范围-32768到32767）
      - int（范围-21亿到21亿）
      - long（范围很多）
    - 浮点类型
      - float占4个字节
      - double占8个字节
    - 字符类型char占2个字节
  - boolean类型：占1位其值只有true和false两个
- 引用类型（reference type）
  - 类
  - 接口
  - 数组

public class dome02 {
    public static void main(String[] args) {
        //八大基本数据类型

        //整数
        int num1 = 10;  //常用
        byte num2 = 20;
        short num3 = 30;
        long num4 = 40L; //long类型要在数字后面加L

        //小数：浮点数
        float num5 = 50.1F; // float类型要在数字后面加个F
        double num6 = 3.1415926;

        //字符
        char name = '国';

        //字符串，String不是关键字，类
        //String namea = "张三";

        //布尔值
        boolean flag = false;
        boolean flags = true;
    }
}

什么是字节？

位(bit)：计算机内部存储最小的单位，11001100是一个八位二进制数。
字节(byte)：是计算机中数据处理的基本单位，习惯上用大写B来表示。
1B(byte,字节) = 8bit(位)
字符：是指计算机中使用的字母，数字，字和符号

数据类型的拓展

public class dome03 {
    public static void main(String[] args) {
        //整数拓展： 进制   二进制0b   十进制   八进制0   十六进制0x
        int i = 10;
        int i2 = 010;   //八进制0
        int i3 = 0x10;  //十六进制0x

        System.out.println(i);
        System.out.println(i2);
        System.out.println(i3);
        System.out.println("=========");

        //==========================================
        //浮点数拓展
        //BigDecimal   数学工具类

        //float 有限  离散  舍入误差  大约  接近但不等于
        //double
        //最好完全避免使用浮点数进行比较

        float f = 0.1f; //0.1
        double d = 1.0/10; //0.1

        System.out.println(f==d);//false

        float d1 = 23232323232f;
        float d2 = d1+1;
        System.out.println(d1==d2); //true
        System.out.println("=========");

        //==========================================
        //字符拓展

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

        System.out.println(c1);
        System.out.println((int)c1); //强制转换 // 97
        System.out.println(c2);
        System.out.println((int)c2); //强制转换 // 20013

        //所有的字符本质还是数字
        //编码  Unicode  97 = a   2字节  65536  Excel 2的16次方 = 65536

        char c3 = '\u0061';
        System.out.println(c3);  //a

        //转移字符
        // \t  制表符
        // \n  换行
        System.out.println("hello'\nworld");

        System.out.println("===========");
        String sa = new String("hello world");
        String sb = new String("hello world");
        System.out.println(sa==sb);

        String sc = "hello world";
        String sd = "hello world";
        System.out.println(sc==sd);
        //对象 从内存分析

        //布尔值扩展
        boolean flag = true;
        if(flag) {}
    }
}

三、类型转换

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

低————————————————————————————————————————>高
byte,short,char->int->long->float->double

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

1. 强制类型转换

2.自动类型转换

实例1：

public class dome04 {
    public static void main(String[] args) {
        int i = 128;
        byte b = (byte)i;   //内存溢出

        //强制转换   (类型)变量名    高->低

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


        //自动类型转换   低-> 高
        int a = 128;
        double c = a;
        System.out.println(a); //128
        System.out.println(c); //128


        /*
        注意：
        1. 不能对布尔值进行转换。
        2. 不能把对象类型转换为不相干的类型。
        3. 把高容量转换到低容量的时候，强制转换
        4. 转换的时候可能存在内存溢出，或者精度问题
        */

        System.out.println("======================");
        System.out.println((int)23.7); //23
        System.out.println((int)-45.89f); //-45


        System.out.println("=============");
        char e = 'a';
        int f = e+1;
        System.out.println(f);
        System.out.println((char)f);
    }
}

实例2：

public class dome05 {
    public static void main(String[] args) {
        //操作比较大的数据的时候，注意溢出问题
        //JDK7新特性，数字之间可以用下划线分割
        int money = 10_0000_0000;
        int years = 20;
        int total = money * years; //-1474836480, 计算的时候溢出了
        long total2 = money * years; //-1474836480,默认是int，转换之前已经存在问题了

        long totle3 = money * ((long)years); //20000000000, 先把一个数转换为long
        System.out.println(totle3);
    }
}

四、变量、常量

Java是一种强类型语言，每个变量都必须声明其类型、
Java变量是程序中最基本的储存单元，其要素包括变量名，变量类型和作用域。

type varName [=value] [{,varName[=value]}];
//数据类型 变量名=值； 可以使用逗号隔开来声明多个通类型变量

注意事项
- 每个变量都有类型，类型可以是基本类型，也可以是引用类型。
- 变量名必须是合法的标识符。
- 变量名称是一条完整的语句，因此每个声明都必须以分号结束。

1.变量的声明

public class dome06 {
    public static void main(String[] args) {
        //int a,b,c;
        //int a=1,b=2,c=3; //程序的可读性
        String name="张三";
        char x='X';
        double pi=3.14;
    }
}

2. 变量作用域

类变量
实例变量
局部变量

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

实例1：

public class dome08 {
    //属性：变量

    //实例变量:从属于对象; 如果不自行初始化，这个类型的默认值 0  0.0
    //布尔值：默认值false
    //除了基本类型，其余的默认值都是null
    String name;
    int age;

    //类变量 static
    static  double salary = 2500;


    //main方法
    public static void main(String[] args) {

        //局部变量：必须声明和初始化
        int i =10;
        System.out.println(i);
        //变量类型 变量名字 = new dome08();
        dome08 dome08 = new dome08();
        System.out.println(dome08.age);//0
        System.out.println(dome08.name);//null

        //类变量
        System.out.println(salary);//2500;
    }

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

    }
}

3. 常量

public class dome09 {

    //修饰符，不存在先后顺序
    //通过final定义常量
    static final double PI = 3.14;
    final static double PI1 = 3.14;

    public static void main(String[] args) {
        System.out.println(PI);
    }
}

4. 变量的命名规范

所有的变量、方法、类名：见名思意
类成员变量：首字母小写和驼峰原则：monthSalary
局部变量：首字母小写和驼峰原则
常量：大写字母和下划线：MAX_VALUE
类名：首字母大写和驼峰原则：Man，GoodMan
方法名：首字母小写和驼峰原则：run()，runRun()

五、运算符

算数运算符：+、-、*、/、%、++、–
赋值运算符：=
关系运算符：>、<、>=、<=、==、!=、instanceof
逻辑运算符：&&、||、!
位运算符：&、|、^、~、>>、<<、>>>（了解）
条件运算符（三步运算符）：？：
扩展赋值运算符：+=、-=、*=、/=

1. int除法问题

实例1：

public class Demo01 {
    public static void main(String[] args) {
        // 二元运算符
        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); // 0.5
        System.out.println(a/b); // 0 // 注意数据类型的转换
    }
}

2. 不同类型整数相加问题

实例2：

public class Demo02 {
    public static void main(String[] args) {
        long a = 12323123123123L;
        int b = 123;
        short c =12;
        byte d = 1;
        System.out.println(a+b+c+d); //Long类型
        System.out.println(b+c+d); //Int类型
        System.out.println(c+d); //Int类型
    }
}

3. 关系运算符返回结果问题

实例3：

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

        System.out.println(c%a); // 1

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

4. 自加自减问题

public class Demo04 {
    public static void main(String[] args) {
        // ++ -- 自增，自减
        int a = 3;
        int b = a++; // 先赋值在自增
        int c = ++a; // 先自增在赋值

        //幂运算  很多运算，我们会使用工具类操作

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

    }
}

5. 逻辑运算符

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)); // 如果为真，则为假

        //短路运算
        int c =5;
        boolean d = (c<4)&&(c++<4);
        System.out.println(d); //false
        System.out.println(c); //5

    }
}

6. 位运算

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

           A&B = 0000 1100 //与，如果有都为0，否则为1
           A|B = 0011 1101 //或，如果都为0则为0，否则为1
           A^B = 0011 0001 //如果相同为0否则为1
           ~B = 1111 0010 //取反

           <<  类似  *2
           >>  类似  /2
           0000 0000   0
           0000 0001   1
           0000 0010   2
           0000 0011   3
           0000 0100   4
           0000 1000   8
           0001 0000   16
        */
        System.out.println(2<<3); //16
    }
}

7. 扩展赋值运算符

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

        a+=b;
        System.out.println(a); //30
        a-=b;

        //字符串拼接
        System.out.println(""+a+b); //1020
        System.out.println(a+b+""); //30
    }
}

8. 三元运算符

public class Demo08 {
    public static void main(String[] args) {
        //x ? y : z
        //如果x==true,则结果为y,否则为z
        int score = 50;
        String type = score < 60 ? "不及格" : "及格";
        //if

        System.out.println(type);
    }
}

9. 优先级

()

六、包机制、JavaDoc

1. 包机制

为了更好的组织类，Java提供了包机制，用于区别类名的命名空间、
包语句的语法格式为：
```
package pkg[. pkg2[. pkg3...]];
```
一般利用公司域名倒置作为包名；
为了能够使用某个包的成员，我们需要在java程序中明确导入该包。使用“import”语句可以完成此功能
```
import package1[.package2...].(classname|*)
```

2. JavaDoc

JavaDoc命令是用来生成自己的api文档的
参数信息
- @author 作者名
- @varsion 版本号
- @since 指明需要最早使用的jdk版本
- @param 参数名
- @return 返回值情况
- @throws 异常抛出情况
```
javadoc -encoding UTF-8 -charset UTF-8 Doc.java
```