Java基础语法

基础语法

注释

1. 单行注释 //
2. 多行注释 /* */
3. 文档注释 /** */

---

标识符

类名，变量名以及方法名均被称为标识符

注：

所有开头必须为大小写字母，$，下划线_，后面随意

不能使用关键字作为变量或方法名 ， 必须区分清楚大小写

用英语代替汉字和拼音

• 关键字

  Java关键字类别	Java关键字	关键字含义
  访问控制	private	一种访问控制方式：私用模式，访问控制修饰符，可以应用于类、方法或字段（在类中声明的变量）
  访问控制	protected	一种访问控制方式：保护模式，可以应用于类、方法或字段（在类中声明的变量）的访问控制修饰符
  访问控制	public	一种访问控制方式：共用模式，可以应用于类、方法或字段（在类中声明的变量）的访问控制修饰符。
  类、方法和变量修饰符	abstract	表明类或者成员方法具有抽象属性，用于修改类或方法
  类、方法和变量修饰符	class	声明一个类，用来声明新的Java类
  类、方法和变量修饰符	extends	表明一个类型是另一个类型的子类型。对于类，可以是另一个类或者抽象类；对于接口，可以是另一个接口
  类、方法和变量修饰符	final	用来说明最终属性，表明一个类不能派生出子类，或者成员方法不能被覆盖，或者成员域的值不能被改变，用来定义常量
  类、方法和变量修饰符	implements	表明一个类实现了给定的接口
  类、方法和变量修饰符	interface	接口
  类、方法和变量修饰符	native	用来声明一个方法是由与计算机相关的语言（如C/C++/FORTRAN语言）实现的
  类、方法和变量修饰符	new	用来创建新实例对象
  类、方法和变量修饰符	static	表明具有静态属性
  类、方法和变量修饰符	strictfp	用来声明FP_strict（单精度或双精度浮点数）表达式遵循IEEE 754算术规范
  类、方法和变量修饰符	synchronized	表明一段代码需要同步执行
  类、方法和变量修饰符	transient	声明不用序列化的成员域
  类、方法和变量修饰符	volatile	表明两个或者多个变量必须同步地发生变化
  程序控制	break	提前跳出一个块
  程序控制	continue	回到一个块的开始处
  程序控制	return	从成员方法中返回数据
  程序控制	do	用在do-while循环结构中
  程序控制	while	用在循环结构中
  程序控制	if	条件语句的引导词
  程序控制	else	用在条件语句中，表明当条件不成立时的分支
  程序控制	for	一种循环结构的引导词
  程序控制	instanceof	用来测试一个对象是否是指定类型的实例对象
  程序控制	switch	分支语句结构的引导词
  程序控制	case	用在switch语句之中，表示其中的一个分支
  程序控制	default	默认，例如：用在switch语句中，表明一个默认的分支。Java8 中也作用于声明接口函数的默认实现
  错误处理	try	尝试一个可能抛出异常的程序块
  错误处理	catch	用在异常处理中，用来捕捉异常
  错误处理	throw	抛出一个异常
  错误处理	throws	声明在当前定义的成员方法中所有需要抛出的异常
  包相关	import	表明要访问指定的类或包
  包相关	package	包
  基本类型	boolean	基本数据类型之一，声明布尔类型的关键字
  基本类型	byte	基本数据类型之一，字节类型
  基本类型	char	基本数据类型之一，字符类型
  基本类型	double	基本数据类型之一，双精度浮点数类型
  基本类型	float	基本数据类型之一，单精度浮点数类型
  基本类型	int	基本数据类型之一，整数类型
  基本类型	long	基本数据类型之一，长整数类型
  基本类型	short	基本数据类型之一,短整数类型
  基本类型	null	空，表示无值，不能将null赋给原始类型（byte、short、int、long、char、float、double、boolean）变量
  基本类型	true	真，boolean变量的两个合法值中的一个
  基本类型	false	假，boolean变量的两个合法值之一
  变量引用	super	表明当前对象的父类型的引用或者父类型的构造方法
  变量引用	this	指向当前实例对象的引用，用于引用当前实例
  变量引用	void	声明当前成员方法没有返回值，void可以用作方法的返回类型，以指示该方法不返回值
  保留字	goto	保留关键字，没有具体含义
  保留字	const	保留关键字，没有具体含义，是一个类型修饰符，使用const声明的对象不能更新

---

数据类型

强类型语言是要求变量必须先定义后才能使用，且还需要严格符合规定

弱类型语言与前者刚好相反

Java数据类型分为两大类：

1. 基本类型
   • 数值类型：
     • 整数类型：
       1. byte(1个字节) -128-127
       2. short(2个字节) -32768-32767
       3. int(4个字节) -2147483648-2147483647
       4. long(8个字节) -9223372036854775808-9223372036854775807
     • 浮点类型：
       1. float(4个字节)
       2. double(8个字节)
     • 字符类型：
       1. char(2个字节)
   • **Boolean类型：**1位，只有true和false两个
2. 引用类型：
   1. 类
   2. 接口
   3. 数组

如下表示：

public class Demo02 {
    public static void main(String[] args) {
        //八大数据类型
        //整数
        int num01 = 10;    //最常用
        byte num02 = 20;
        short num03 = 30;
        long num04 = 30L;   //Long类型要在数字后面加L

        //小数；浮点数
        float num05 = 50.1F;  //float类型要在数字后面加F
        double num06 = 3.1415926;
     //boolean flag = false;


    }
}

字节

bit：内部数据储存最小单位

Byte：数据处理基本单位

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

1. bit：表示1位
2. Btye：表示一个字节 1B=8b
3. 1024B=1KB 1024KB=1M 1024M=1G 1024G=1TB

拓展例题

public class Demo03 {
    public static void main(String[] args) {
        //整数扩展  进制  二进制0b  十进制  八进制0  十六进制0x

        int i = 10;
        int i2 = 010;  //八进制 由0开头
        int i3 = 0x10;  //十六进制 由0x开头    0-9  A-F  F=16

        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 = 232312312323123f;
        float d2 = d1 + 1;

        System.out.println(d1==d2);  //结果：ture
        System.out.println("==========================================");


        //===============================================================
        //字符拓展(底层原理)
        //===============================================================
        char c1 = 'a';
        char c2 = '中';

        System.out.println(c1);

        System.out.println((int)c1);  //强制换行

        System.out.println(c2);

        System.out.println((int)c2);  //强制换行

        //所有的字符本质是数字
        //编码：Unicode  占2个字节  最多65536个字符  Excel表格最长2^16=65536个字符
        //Unicode 有对照表：（97 = a 65 = A）  表示方法：U0000-UFFFF

        char c3 = '\u0061';

        System.out.println(c3);  //会输出a
        
        //转义字符
        // \t  制表符
        // \n  换行符
        //......等

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

        System.out.println("=================================================");
        String sa = new String(original:"hello world");  //original:初始化
        String sb = new String(original:"hello world");
        System.out.println(sa==sb);  //false

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

        //布尔值扩展
        boolean flag = true;
        if (flag==true){}    //详细
        if (flag){}   //简写
        //精简易读

    }
}

类型转换

概念

byte , short , char—> int—>long—>float—>double

浮点型的优先级大于整数型

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

• 强制类型转换 高到低
• 自动类型转换 低到高

注意：
1.不能转换布尔值（Boolean）
2.不能把对象类型转换为不相干的类型
3.高容量转低容量要强制转换，低到高不用强制
4.转换可能存在内存溢出，或者精度问题，导致结果不准确

例：

public class Demo04 {
    public static void main(String[] args) {
        int i = 128;
        byte b = (byte)i;  //强制转换  尽量避免内存溢出

        //强制转换格式：（类型）变量名   规则：高容量转低容量
        //自动转换          规则：低容量到高容量

        System.out.println(i);
        System.out.println(b);

        int i1 = 128;
        double b1 = i1;  //自动转换  不需强制  尽量避免内存溢出

        System.out.println(i1);
        System.out.println(b1);

        /*
        注意：
        1.不能转换布尔值（Boolean）
        2.不能把对象类型转换为不相干的类型
        3.高容量转低容量要强制转换，低到高不用强制
        4.转换可能存在内存溢出，或者精度问题，导致结果不准确
         */

        System.out.println("========================");
        //浮点型转换为整数型
        System.out.println((int)23.7);  //输出23
        System.out.println((int)-45.89f);  //输出-45

        System.out.println("========================");
        char c = 'a';
        int d = c+1;
        System.out.println(d);
        System.out.println((char) d);   //强转

    }
}

溢出问题解决方法

public class Demo05 {
    public static void main(String[] args) {
        //操作数大时，注意溢出问题
        //JDK特性：数字间可用下滑线分割
        int money = 10_0000_0000;
        int years = 20;
        int total = money*years;  
        System.out.println(total1);  //运行的时候出现错误：-1474836480，原因：溢出范围
        
        long total2 = money*years;
        System.out.println(total2);  //结果不变，原因：默认int，转换前出现问题，转换后一样有问题

        long total3 = money*((long)years);
        System.out.println(total3);  //先把一个数转换成Long，结果才会正确

    }
}

变量

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

type varName  [=value] [{,varName[=value]}] ;
//数据类型  变量名 = 值：声明多个同类型变量时用逗号隔开

常量

定义后，不能改变的值, 常量名一般使用大写字符

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

如下所示：

public class Demo08 {

    //定义常量
    //修饰符，不存在先后顺序
    //final static double PI = 3.14;这样写也可以
    static final double PI = 3.14;

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

    }
}

常量规范

• 类成员变量，局部变量，方法名：
• 首字母小写驼峰原则，如：monthSalary（月工资）
• 类名：首字母大写驼峰原则，如：Black BlackPink
• 常量：大写字母和下划线，如：MAX_VALUE

运算符

• 算术运算符：+ , - ,* , / ,% (模=取余) ,++ , –

如下所示：

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);  //结果出现小数要转换类型
    }
}

如下所示：

package operator;

import sun.applet.Main;

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;  //执行完此代码，先自增，再给c赋值
        // a++ = a + 1

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

        //幂运算 2^3  2*2*2 = 8    运算会借助工具类操作
        double pow = Math.pow(2, 3);
        System.out.println(pow);
    }
}

• 赋值运算符：=
• 关系运算符：> , < , >= , <= , ==(等于) , !=(不等于) , instanceof

如下所示：

package operator;

public class Demo03 {
    public static void main(String[] args) {
        //关系运算符返回的结果：用来判断正确或者错误  用布尔值(boolean)表示

        int a = 10;
        int b = 20;
        int c = 21;

        System.out.println(c%a);  //c / a = 21 / 20 = 2 ··· 1

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

• 逻辑运算符(与或非)：&& , || , !

如下所示：

package operator;

//逻辑运算符
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));  //如果是真则为假，如果是假则为真，

        //短路运算
        int c = 5;
        boolean d = (c<4)&&(c++<4);
        //因为5<4,所以第一个错，导致不会运算第二个

        System.out.println(d);  //此时不会输出d的值
        System.out.println(c);
    }
}

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

如下所示：

package operator;

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

        与，A&B = 0000 1100  （都为1才是1，否则为0）
        或，A|B = 0011 1101  （只要有一个1，就为1）
        非，A^B = 0011 0001  （相同为0，不同为1）
        取反,~B = 1111 0010  （1为0,0为1）

        2*8 = 16 = 2*2*2*2
        <<(左移):  *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);

    }
}

• 条件运算符：? , :

如下所示：

package operator;

//三元运算符
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);
    }
}

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

如下所示：

package operator;

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

        a+=b;
        a-=b;

        System.out.println(a);

        //字符串连接符   + , String
        //在加号运算符的两侧出现String类型（字符串） 他就会把另外几项均转为String类型进行拼接
        //字符串在前面时会进行拼接，在后面的时候不影响前面，依旧会进行运算
        System.out.println(""+a+b);  //结果为 1020
        System.out.println(a+b+"");  //结果为 30

    }
}

** 优先级用**()**括起来

包机制

• 作用：用于区别类名的命名空间

• 本质：文件夹

  • 语法格式：package pkg1[. pkg2[. pkg3...]];

  • 一般利用公司域名倒置作为包名

  • import可以导入包

    • 语法格式: import package[.package].(classname|*);

JavaDoc

• 作用：生成自己的API文件
  • 注意：加在类上面就是类的注释，加在方法上面就是方法的注释
• 参数信息：
  • @author 作者名
  • @version 版本号
  • @since 指明需要最早使用的jdk版本
  • @param 参数名
  • @return 返回值情况
  • @throws 异常抛出情况

如下所示：

package operator;

/**
 * @author xu
 * @version 1.0
 * @since 1.8
 */
public class Doc {

    String name;

    /**
     *
     * @param name
     * @return
     * @throws Exception
     */
    public String text(String name) throws Exception{
        return name;
    }
    
}