Java基础语法//2020.6.8

知识点来源：bilibli狂神说

IDEA快捷键

psvm：

public static void main(String[] args) {
}

sout：

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

注释、标识符、关键字

• 注释：代码量较大时使用

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

public class HelloWorld {
    public static void main(String[] args) {
        //我是单行注释
        System.out.println("Hello,World!");
        /*
        我是多行注释
        我是多行注释
        我是多行注释
        我是多行注释
        我是多行注释
        我是多行注释
        我是多行注释
        */
/**
 * 我是JavaDoc注释
 * @可添加属性 使用较少
 * @Description：
 * @Author：
 */
    }
}

• 标识符、关键字

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

  标识符都应该以大小写字母，美元符$、下划线_开始，除此之外不行。

  标识符大小写敏感。

  String Man = "Me";
  
  String man = "Me";
  

  可以使用中文命名，一般不建议使用。

  不能使用关键字作为变量名或方法名。

  关键字表：

  

---

数据类型

强类型语言

​ 要求变量的使用要严格符合规定，所有变量都必须先定义后 才能使用。

Java的数据类型分为基本类型、引用类型。

基本类型

1.数值类型

• 整数类型：byte（占1字节范围）：-128-127

  ​ short（占2字节范围）：-32768-32767

  ​ int（占4字节范围）：-2147483648-2147483647

  ​ long（占8字节范围）：-9223372036854775808-9223372036854775807

  ​ 使用long类型要在数值后加L

  long num1 = 30L;
  

  整数拓展：二进制0b开头 八进制0开头 十六进制0x开头

• 浮点类型：float（占4字节范围）

  ​ 使用float类型要在数值后面加F

  float num2 = 50.1F;
  

  ​ double（占8字节范围）

  double num3 = 3.1415926;
  

  尽量少用浮点数进行比较操作，会有精度误差！

  尽量少用浮点数进行比较操作，会有精度误差！

  尽量少用浮点数进行比较操作，会有精度误差！

• 字符类型char占两个字节范围

  字符：

  char name = 'A';
  

  字符串：

  String不是关键字，是一个类（引用类型）

  String name1 = "吴彦祖"；
  

  字符拓展：

  char c1 = 'A';
  
  System.out.println((int)c1);//强制类型转换，输出的是ASCII码值
  System.out.println("Hello\nWorld");//转义字符    \n表示换行
  

2.boolean类型：占1位且其值只有true和false两个,代表是非。

boolean flag = true;

boolean falg = false;

boolean拓展：

boolean flag = true;
if(flag){
    ...
}

引用类型

1.类

银行业务避免使用浮点数 用BigDecimal数学工具类

2.接口

未复习到，之后会补充

3.数组
未复习到，之后会补充

---

类型转换

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

低---------------------------------→高
byte,short,char,int,long,float,double

强制类型转换：操作：(类型)变量名 优先级高→低

int i = 128;
byte b = (byte)i;//强制转换
System.out.println((int)32.7);
System.out.println((int)42.65F);
//应避免内存溢出；b=-127；

自动类型转换：优先级低→高 (自动转换，无需操作)

int i = 128;
double b = i;//自动转换

注意点：

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

---

变量、常量、作用域

Java中每一个变量都必须声明其类型。

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

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

作用域

类变量

实例变量：从属于对象，如果不自行初始化，数值类型的默认值为0（整数）、0.0（小数）

​ boolean值默认为false。

​ 除了基本类型，其余的默认值都是null。

局部变量

public class Demo{
	static int a;//类变量  static打头
    
	String str;//实例变量
	int i;//实例变量
    boolean flag;//实例变量
    

	public static void main(String[] args) {
		int i = 0;//局部变量
        Demo demo = new Demo();
        System.out.println(demo.str);//实例变量的输出
        System.out.println(demo.i);//实例变量的输出
        System.out.println(demo.boolean);//实例变量的输出
        
        System.out.println(a);//类变量的输出
        
	}
}

常量

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

常量可以理解成一种特殊的变量，它的值被设定后，在程序运行过程中不允许被改变。

final 变量名 = 值；

final double PI = 3.14；

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

final static double PI = 3.14;
//修饰符 不分先后顺序
static final double PI = 3.14;

命名规范

类成员变量：首字母小写和驼峰原则：monthSalary
局部变量：首字母小写和驼峰原则
常量：大写字母和下划线： MAX_VALUE
类名：首字母大写和驼峰原则：Man， GoodMan
方法名：首字母小写和驼峰原则：run（）， runRun（）

---

运算符

Java 语言支持如下运算符：
算术运算符:：+，-，，/，%，++，–
赋值运算符：=
关系运算符：>，<，>=，<=，==，!= instanceof
逻辑运算符：&&，||，!
位运算符：&，|，^，~ ， >>，<<，>>> (了解！！！)
条件运算符： ？：
扩展赋值运算符：+=，-=，*=，/=

1、二元运算符

两个操作数之间的运算

public static void main(String[] args){
	int a = 10;
	int b = 20;
	System.out.println("a + b = " + (a + b) );
	System.out.println("a - b = " + (a - b) );
	System.out.println("a * b = " + (a * b) );
	System.out.println("b / a = " + (b / a) );
}

包括整数运算、浮点运算和关系运算符

整数运算

如果两个操作数有一个为Long, 则结果也为long
没有long时，结果为int。即使操作数全为shot,byte，结果也是int.

public static void main(String[] args) {
	long a = 1231321311231231L;
	int b = 1213;
	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类型
}

浮点运算

如果两个操作数有一个为double, 则结果为double.
只有两个操作数都是float, 则结果才为float.

public static void main(String[] args) {
	float a = 3.14565F;
	double b = 3.194546464;
	float c = 1.3123123F;
	
	System.out.println(a+b); //double类型
	System.out.println(b+c); //double类型
	System.out.println(a+c); //float类型
}

关系运算符

返回布尔值

运算符	描述	例子（设A<B）
==	检查如果两个操作数的值是否相等，如果相等则条件为真。	（A==B）为假
!=	检查如果两个操作数的值是否相等，如果值不相等则条件为真。	（A!=B）为真
>	检查左操作数的值是否大于右操作数的值，如果是那么条件为真。	（A>B）为假
<	检查左操作数的值是否小于右操作数的值，如果是那么条件为真。	（A<B）为真
>=	检查左操作数的值是否大于或等于右操作数的值，如果是那么条件为真。	（A>=B）为假
<=	检查左操作数的值是否小于或等于右操作数的值，如果是那么条件为真。	（A<=B）为真

2、取模运算

即取余； 5%3 余 2
其操作数可以为浮点数,一般使用整数。如：5.9%3.9=2.000000004
要点：
负数%负数＝负数；
负数%正数＝负数；
正数%负数＝正数；

public static void main(String[] args) {
	System.out.println(9 % 4); //1
	System.out.println(-9 % -4); //-1
	System.out.println(-10 % 4); //-2
	System.out.println(9 % -4); //1
}

一般都是正整数运算，进行结果判断

3、一元运算符

自增（++）自减（–）运算符是一种特殊的算术运算符，在算术运算符中需要两个操作数来进行运算，
而自增自减运算符是一个操作数，分为前缀和后缀两种。

a++：先使用a再使其自增1

++a：先使其自增1再使用

java中的乘幂处理

例：3的2次方计算

public static void main(String[] args) {
	int a = 3^2; //java中不能这么处理， ^是异或符号。
	double b = Math.pow(3, 2);
}

4、逻辑运算符

逻辑与：&&和&，逻辑或：||和|，逻辑非：！

操作符	描述	例子
&&	称为逻辑与运算符。当且仅当两个操作数都为真，条件才为真。	（A&&B）为假
||	称为逻辑或操作符。如果任何两个操作数任何一个为真，条件为真	（A||B）为真
！	称为逻辑非运算符。用来反转操作数的逻辑状态。如果条件为tue，则逻辑非运算符将得到false	!（A&&B）为真

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, 则直接返回false
逻辑或只要有一个为true, 则直接返回true

5、位运算符

Java定义了位运算符，应用于整数类型(int)，长整型(long)，短整型(short)，字符型(char)，和字节型
(byte)等类型。位运算符作用在所有的位上，并且按位运算。

A = 0011 1100
B = 0000 1101
-----------------
A&B = 0000 1100
A | B = 0011 1101
A ^ B = 0011 0001
~A= 1100 0011

2*8的最快运算方法：

public static void main(String[] args) {
	System.out.println(2 << 3);//左移三位
}

6、字符串连接符

“+” 运算符两侧的操作数中只要有一个是字符串(String)类型，系统会自动将另一个操作数转换为字符串
然后再进行连接。

String s1="Hello 中文!";
String s2=1+""; //转换成String
//int
int c = 12;
System.out.println("c=" + c);

7、三目条件运算符

x?y:z

类似于if语句 x为条件 y、z为分支语句

public static void main(String[] args) {
	int score = 80;
	String type = score < 60 ? "不及格" : "及格";
	System.out.println("type= " + type);
}

---

包机制

包的作用：为了更好地组织类，Java 提供了包机制，用于区别类名的命名空间。

1、把功能相似或相关的类或接口组织在同一个包中，方便类的查找和使用。
2、如同文件夹一样，包也采用了树形目录的存储方式。同一个包中的类名字是不同的，不同的包中的类
的名字是可以相同的，当同时调用两个不同包中相同类名的类时，应该加上包名加以区别。因此，包可
以避免名字冲突。
3、包也限定了访问权限，拥有包访问权限的类才能访问某个包中的类。
Java 使用包（package）这种机制是为了防止命名冲突，访问控制，提供搜索和定位类（class）、接
口、枚举（enumerations）和注释（annotation）等。

包语句的语法格式

package pkg1[．pkg2[．pkg3…]];

例如,一个Something.java 文件它的内容:

package net.java.util;
	public class Something{
	...
	}

它的路径应该是 net/java/util/Something.java 这样保存的。 package(包) 的作用是把不同的
java 程序分类保存，更方便的被其他 java 程序调用。

一个包（package）可以定义为一组相互联系的类型（类、接口、枚举和注释），为这些类型提供访问
保护和命名空间管理的功能。
以下是一些 Java 中的包：
java.lang-打包基础的类
java.io-包含输入输出功能的函数
开发者可以自己把一组类和接口等打包，并定义自己的包。而且在实际开发中这样做是值得提倡的，当
你自己完成类的实现之后，将相关的类分组，可以让其他的编程者更容易地确定哪些类、接口、枚举和
注释等是相关的。
由于包创建了新的命名空间（namespace），所以不会跟其他包中的任何名字产生命名冲突。使用包这
种机制，更容易实现访问控制，并且让定位相关类更加简单。

创建包

创建包的时候，你需要为这个包取一个合适的名字。之后，如果其他的一个源文件包含了这个包提供的
类、接口、枚举或者注释类型的时候，都必须将这个包的声明放在这个源文件的开头。
包声明应该在源文件的第一行，每个源文件只能有一个包声明，这个文件中的每个类型都应用于它。
如果一个源文件中没有使用包声明，那么其中的类，函数，枚举，注释等将被放在一个无名的包
（unnamed package）中。
一般利用公司域名倒置作为报名；
例子：
www.baidu.com 包名：com.baidu.www
bbs.baidu.com 包名：com.baidu.bbs

import 关键字(需再复习)

为了能够使用某一个包的成员，我们需要在 Java 程序中明确导入该包。使用 “import” 语句可完成此功
能。
在 java 源文件中 import 语句应位于 package 语句之后，所有类的定义之前，可以没有，也可以有多
条，其语法格式为：

import package1[.package2…].(1 classname|*);

如果在一个包中，一个类想要使用本包中的另一个类，那么该包名可以省略。
要是要用到其他包下的类，就必须要先导包
如果两个类重名，需要导入对应的包，否则就需要写出完整地址

用 import 关键字引入，使用通配符 “*” , 导入io包下的所有类

import java.io.*;//全局扫描 时间效率低

---

JavaDoc

JavaDoc是一种将注释生成HTML文档的技术，生成的HTML文档类似于Java的API，易读且清晰明了。

• /** 这是一个Javadoc测试程序
  
  * @author Kuangshen
  * @version 1.0
  * @since 1.5
  * */
  
  public class HelloWorld {
  public String name;
  /**
  
  * @param name 姓名
  * @return 返回name姓名
  * @throws Exception 无异常抛出
  * */
    public String function(String name) throws Exception{
    return name;
    }
    }