Java基础知识二

Java基础语法

1.标识符

Java 所有的组成部分都需要名字。就如同我们每一个人都有自己的名字一样。在Java中的类名、变量名以及方法名都需要起名。我们把所起的名字称为标识符。
关于 Java 标识符，有以下几点需要注意：

• 所有的标识符都应该包含字母（A-Z 或者 a-z）,数字，美元符（$）、或者下划线（_），但不能含有特殊字符@、%、空格等
• 不能以数字开头,例如:123s就是不合法的
• 标识符严格区分大小写
• 不能使用关键字，例如：int long this等
• 标识符最好能够见名知意

2.关键字

Java中一些单词具有特殊的含义，一共有50个关键字
关键字要求全小写，其中有两个保留关键字：const goto
注意：关键字不能用作标识符，上面也有提到。不过除了关键字以外，还有true false null也不能用作标识符。

类别	关键字	说明
访问控制	private	私有的
	protected	受保护的
	public	公共的
	default	默认的
类、方法和变量修饰符	abstract	声明抽象
	class	类
	extends	扩充,继承
	final	最终值,不可改变的
	implements	实现（接口）
	interface	接口
	native	本地，原生方法（非 Java 实现）
	new	新，创建
	static	静态
	strictfp	严格、精准
	synchronized	线程、同步
	transient	短暂
	volatile	易失
程序控制语句	break	跳出循环
	case	定义一个值以供 switch 选择
	continue	继续
	default	默认
	do	运行
	else	否则
	for	循环
	if	如果
	instanceof	实例
	return	返回
	switch	根据值选择执行
	while	循环
错误处理	assert	断言表达式是否为真
	catch	捕捉异常
	finally	有没有异常都执行
	throw	抛出一个异常对象
	throws	声明一个异常可能被抛出
	try	捕获异常
包相关	import	导入
	package	包
基本类型	boolean	布尔类型
	byte	字节型
	char	字符型
	double	双精度浮点
	float	单精度浮点
	int	整型
	long	长整型
	short	短整型
变量引用	super	父类,超类
	this	本类
	void	无返回值
保留关键字	goto	是关键字，但不能使用
	const	是关键字，但不能使用

3.注释

程序员可以在代码里写一些注释。
编译器会忽略注释，因此不会影响程序的执行结果。
注释的真正作用是： 它可以向任何阅读代码的人描述或者解释程序的实现思路,如何使用以及其它任何相关信息， 提高代码的可读性,方便后期的维护与复用。
Java注释有3种：
3.1单行注释：注释单行内容
格式：“//”
快捷方式：Ctrl+/ 再按一次取消
3.2 多行注释：注释多行内容,虽然叫多行注释,也可注释单行内容.
格式：“/*”开头，“*/” 结束
快捷方式：可以输入" /* "之后按回车添加注释
3.3文档注释: 一般用来注释类和方法,通过注释内容来记录类或者方法的信息.
格式：“/**”开头，“*/” 结束
快捷方式：可以输入" /** "之后按回车添加注释

4.变量

变量来源于数学，是计算机语言中能储存计算结果或能表示值的抽象概念。
描述变量的三个元素：变量类型 变量名 变量值
定义变量的方式：
方式一：声明变量的同时进行赋值：例如：int age=18;
方式二：先声明再赋值：例如： int age; age=18;
4.1局部变量
位置：局部变量声明在方法、构造方法或者语句块中；
注意：局部变量被声明后，必须经过手动初始化，才可以使用。
生命周期:局部变量在方法、构造方法、或者语句块被执行的时候创建，当它们执行完成后，变量将会被销毁；

package cn.test;
 
public class Test{ 
   public void dogAge(){
   //定义局部变量
      int age = 0;
      age = age + 7;
      System.out.println("小狗的年龄是: " + age);
   }
   
   public static void main(String[] args){
      Test test = new Test();
      test.dogAge();
   }
}

4.2成员变量（实例变量）
位置：类里方法外
注意:不用初始化,也会自动被初始化成默认值，数值型变量的默认值是0，布尔型变量的默认值是false，引用类型变量的默认值是null。
生命周期:实例变量在对象创建的时候创建，在对象被销毁的时候销毁；

package cn.test;
public class TestVariable2 {
    //2.定义成员变量
   int count;
   int sum = 200;
    public static void main(String[] args) {
    //1.定义局部变量
        int sum = 100;//定义在方法中的局部变量sum
        System.out.println(sum);//变量的就近原则:使用的都是自己附近的变量,100
        System.out.println(count);//使用的是成员变量的默认值，0
    }
}

4.3类变量（静态变量）
类变量也称为静态变量，在类中以 static 关键字声明。
位置：必须在方法之外。
注意：静态变量初始化后不可改变。
生命周期：静态变量在第一次被访问时创建，在程序结束时销毁。
静态变量可以通过：ClassName.VariableName的方式访问。即：类名.变量名

import java.io.*;
 
public class Employee {
    //salary是静态的私有变量
    private static double salary;
    // DEPARTMENT是一个常量    public static final
    public static final String DEPARTMENT = "开发人员";
    public static void main(String[] args){
    salary = 10000;
        System.out.println(DEPARTMENT+"平均工资:"+salary);
    }
}

注意：如果其他类想要访问该变量，可以这样访问：Employee.DEPARTMENT

5.数据类型

5.1基本数据类型（8种）
变量要保存值，这个值是存在内存中的，所以就需要向内存申请存储空间

java是一个强类型的语言
为了方便内存管理系统根据变量类型更加合理的分配内存空间
会把我们常见的数据,分成不同类型
不同类型分配的内存大小是不同的，这个大小的单位就是字节Byte

	类型名称	字节空间	取值范围	默认值	包装类
整型	byte	1	-128~127	0	Byte
	short	2	-2^15 到 2^15 - 1	0	Short
	int	4	-2^31 到 2^31 - 1	0	Integer
	long	8	-2^63 到 2^63 -1	0L	Long
浮点型	float	4	单精度浮点型	0.0f	Float
	double	8	双精度浮点型	0.0d	Double
字符型	char	2	0-65535(\u0000-\uffff)	‘\u0000’	Character
布尔型	boolean	1	只有两个取值：true 和 false	false	Boolean

5.2引用数据类型
除了基本类型之外，所有类型都是引用类型的。例如：String类型、数组、类、接口等等。
所有引用类型的默认值都是null。
它的值是指向内存空间的引用，就是地址，所指向的内存中保存着变量所表示的一个值或一组值。
5.3基本类型字面值
在计算机科学中，字面量（literal）是用于表达源代码中一个固定值的表示法（natation）。几乎所有计算机编程语言都具有对基本值的字面量表示。

• 整数类型的字面量默认是int类型（也就是说，我们写一个整数，默认就是int类型的）
• 浮点类型的字面量默认是double类型
• byte、short、char三种类型比int小的整数可以用范围内的值直接进行赋值
• 字面值后缀D L F

long x =99999999999L;//字面值是int类型,需转成long类型的数据,加字面值后缀L即可
float b = 3.0F;//3.0字面值是double类型，加后缀F会变成float类型
double d = 3D;//3字面值是int类型，加后缀D，会变成double类型

• 进制前缀

0b - 标识这是2进制 ,如:0b0101
0 - 标识这是8进制, 8进制是三位,如: 023
0x - 标识这是16进制,如: 0x0001

5.4数据类型转换
整型、实型（常量）、字符型数据可以混合运算。运算中，不同类型的数据先转化为同一类型，然后进行运算。
数据类型转换必须满足的条件：

• 不能对boolean类型进行类型转换。
• 不能把对象类型转换成不相关类的对象。例如不能把Cat类型转为Dog类型
• 在把容量大的类型转换为容量小的类型时必须使用强制类型转换。
• 转换过程中可能导致溢出或损失精度，例如：

int i =128;   
byte b = (byte)i;

因为 byte 类型是 8 位，最大值为127，所以当 int 强制转换为 byte 类型时，值 128 时候就会导致溢出。

• 浮点数到整数的转换是通过舍弃小数得到，而不是四舍五入，例如：

(int)23.7 == 23;        
(int)-45.89f == -45

自动类型转换（隐式转化）
必须满足转换前的数据类型的位数要低于转换后的数据类型，例如: short数据类型的位数为16位，就可以自动转换位数为32的int类型，同样float数据类型的位数为32，可以自动转换为64位的double类型。

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

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

public class ZiDongLeiZhuan{
        public static void main(String[] args){
            char c1='a';//定义一个char类型，16位
            int i1 = c1;//char自动类型转换为int，32位
            System.out.println("char自动类型转换为int后的值等于"+i1);
            char c2 = 'A';//定义一个char类型
            int i2 = c2+1;//char 类型和 int 类型计算
            System.out.println("char类型和int计算后的值等于"+i2);
        }
}

强制类型转换（显式转化）

• 条件是转换的数据类型必须是兼容的。
• 格式：(type)value type是要强制类型转换后的数据类型

int x = 999;
byte y =(byte)x;//大转小,需要强制类型转换

5.5运算规则

• 计算结果的数据类型，与最大的数据类型一致
  比如：int与double类型进行计算，结果为double类型

System.out.println(3/2);//1，int/int,得到的结果类型还是int
System.out.println(3/2d);//1.5，int/double。得到的结果是double

• byte,short,char三种比int小的整数，运算时会先自动转换成int

byte a = 1;
byte b = 2;
byte c = a+b;//错,因为此时的a+b为int类型，int-->byte(大转小，需要强转）
byte c = (byte)(a+b);//对

• 整数运算溢出
  当计算比较大的数据时，比如计算光速运行一年的长度是多少米？计算结果会超出int的取值范围，以此最好的解决方案就是把计算结果转换为Long类型

• 浮点数运算不精确
  我们可以使用java.math.BigDecimal;提供的BigDecimal对象，来解决浮点型运算不精确的问题

• 浮点数的特殊值

Infinity 无穷大 3.14/0
NaN not a number 0/0.0 或 0.0/0

6.运算符

计算机的最基本用途之一就是执行数学运算，作为一门计算机语言，Java也提供了一套丰富的运算符来操纵变量。我们可以把运算符分成以下几组：

算术运算符自增自减
a是操作数，++是自增运算符，--是自减运算符，自增和自减运算符即可以放在变量的前面，也可以放在变量的后面，例如：a++、++a、a–、–a等。
自增（++）：将变量的值加1
分前缀式（如++a）和后缀式（如a++）。前缀式是先加1再使用；后缀式是先使用再加1。
自减（–）：将变量的值减1
分前缀式（如–a）和后缀式（如a–）。前缀式是先减1再使用；后缀式是先使用再减1。

拓展
instanceof 运算符
该运算符用于操作对象实例，检查该对象是否是一个特定类型（类类型或接口类型）。
例如：

String name = "James";
boolean result = name instanceof String; // 由于 name 是 String 类型，所以返回真

如果被比较的对象兼容于右侧类型,该运算符仍然返回true。

class Vehicle {}
 
public class Car extends Vehicle {
   public static void main(String[] args){
      Vehicle a = new Car();
      boolean result =  a instanceof Car;
      System.out.println( result); //结果任为true
   }
}

7.Java方法

7.1方法的定义格式
方法由方法头和方法体组成。方法更像是封装了一个功能。
方法的优点

• 使程序变得更简短而清晰。
• 有利于程序维护。
• 可以提高程序开发的效率。
• 提高了代码的重用性。

修饰符 返回值类型 方法名(参数类型 参数名){
    ...
    方法体
    ...
    return 返回值;
}

接下来我们看一个主函数（程序运行入口函数main()方法），它是由jvm调用的之外，其余和其他方法没有多少区别。
main()方法的格式是固定的。

/** 主方法 */
   public static void main(String[] args) {
      //方法体
   }

方法的调用
程序启动运行，会先执行main()，当在这个过程中遇到其他方法，会先执行这个方法的功能，执行完之后会接着继续执行下面的代码。

8.Java修饰符

8.1访问控制修饰符
Java中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限。

• default (即默认，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。
• private : 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类）
• public : 对所有类可见。使用对象：类、接口、变量、方法
• protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）。
  8.2非访问控制修饰符
  为了实现一些其他的功能，Java 也提供了许多非访问修饰符。
• static 修饰符（静态），用来修饰类方法和类变量。
• final 修饰符，用来修饰类、方法和变量，final 修饰的类不能够被继承，修饰的方法不能被继承类重新定义（不能被重写），修饰的变量，是不可被重新赋值。
• abstract 修饰符，用来创建抽象类和抽象方法。
• synchronized 和 volatile 修饰符，主要用于线程的编程。
  扩展
  transient 修饰符
  序列化的对象包含被 transient 修饰的实例变量时，java 虚拟机(JVM)跳过该特定的变量。

public transient int limit = 55;   // 不会持久化
public int b; // 持久化