javase-javabase-210126-01

javase-javabase-210126-01

• Java关键字 基本类型 引用类型
• 进制 浮点数拓展 编码 转义字符
• 类型转换 JDK7新特性
• 变量 运算符 包机制

---

Java关键字

01	02	03	04	05
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

Java中只能以大小字母，$(美元符)，_(下划线)开头的任意字符组合

基本类型

整数类型：

​ byte 占1个字节 -128~127

​ short 占2个字节 -32768~32767

​ int 占4个字节 -2147483648~2147483647

​ long 占8个字节 （long num=10086L【需要加一个L】）

浮点类型：

​ float 占4个字节 （float num=100.86F【需要加一个F】）

​ fouble 占8个字节

Boolean类型：

​ 占1位，true/false

引用类型

​ 类，接口，数组…

进制

​ 二进制 0b开头

​ 十进制

​ 八进制 0开头

​ 十六进制 0x开头 0_9，AF(10~16)

浮点数拓展

​ float 它是有限的，离散的，舍入误差，大约的(接近但不等于)

​ 少用浮点数比较，最好完全使用浮点数进行比较（比如银行业务【钱】）

​ 使用数学工具类：BigDecimal

float f=0.1f;
double d=1.0/10;
System.out.prinltn(f==d);//false

float num1=555555555555555555;
float num2=num+1;
System.out.println(num1==num2);//true

编码

​ 所有字符的本质还是数字

​ 编码：Unicode 2个字节 0-65536

​ Unicode编码：U0000 UFFFF

​ 表：a=97 A=65

​ char c=’\u0061’;//a 【\u是转义】

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

char c1='a';
char c2='A';
System.out.println((int)c1+"\n"+(int)c2);//97,65

转义字符

​ 制表符 \t

​ 换行 \n

类型转换

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

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

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

int money=10_0000_0000;
int month=12;
int total1=money*month;
long total2=money*month;
System.out.println(total1);//-884901888,,精度溢出
System.out.println(total2);//-884901888,,转换之前已经有问题

long total3=money*((long)month);//先把一个数转换为long
System.out.println(total3);//12000000000

JDK7新特性

​ 数字之间可以用下划线分割

int num=10_0000_0000;//1000000000

变量

1. 局部变量
   • 不许声明初始化
2. 实例变量
   • 从属于对象
   • 如果不初始化，会是默认值，除了基本类型，其余的默认值都是null
   • 布尔类型的默认值是false
3. 类变量
   • ​ static修饰的变量

public class Variate {
    //类变量  static修饰的
    static double height=175;
    //实例变量
    String name;
    int age;
    public static void main(String[] args) {
        //局部变量
        int num=22;
        
        //实例变量，，，必须new
        Variate variate=new Variate();
        System.out.println(variate.name);
        
        //类变量  static
        System.out.println(height);
    }
}

运算符

• 算数运算符 +，-，*，/，%，++，–
• 赋值运算符 =
• 关系运算符 >，<，>=，<=，==，!=instanceof
• 逻辑运算符 &&，||，！
• 位运算符 &，|，^，~，>>，<<，>>>
• 条件运算符 ?:（x?Y:Z 如果x==true，结果为Y，否则为Z）
• 扩展赋值运算符 +=，-=，*=，/=

优先级：

long n1=1000;
int n2=100;
short n3=10;
byte n4=1;

System.out.println(n1+n2+n3+n4);//Long
System.out.println(n2+n3+n4);//int 
System.out.println(n3+n4);//int
        
/*
如果有long/double类型的相加，结果会是long/double类型
如果没有，结果将会是int类型
 */

int a=3;
int b=a++; //执行完这行代码，先给b赋值，再自增
System.out.println(a);//4
System.out.println(b);//3
int c=++a; //执行完这行代码，先自增，再给c赋值
System.out.println(a);//5
System.out.println(b);//3
System.out.println(c);//5

boolean b1=true;
boolean b2=false;

System.out.println("b1 && b2:"+(b1&&b2));//false
//两个变量都为真，结果为true
// 如果前一个为假，则不判断后面（如果b1是假，则不判b2是真假，即不运算b2）
System.out.println("b1 || b2:"+(b1||b2));//
//两个变量其中一个为真，结果为true
System.out.println("!(b1 && b2):"+!(b1&&b2));//true
//如果是真，结果为false；如果是假，结果为true

int b3=5;
boolean d=(b3<3)&&(b3++<10);
System.out.println(d);//false
System.out.println(b3);//5  没有运算b3++

 /*
        A=0011 1100//(二进制)
        B=0000 1101//(二进制)
        ------------------------------------------------------
        A&B 0000 1100		按位计算，都是1，1才是1；否则为0
        A|B 0011 1101		按位计算，至少有一个1比较，才是；否则为0
        A^B 0011 0001		按位计算，位置相同为0，不同为1
        ~B  1111 0010		按位计算，相反

        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 0101	5
        0000 0110	6
        0000 0111	7
        0000 1000	8
        0000 1001   9
        0000 1010	10
        0001 0000   16
         */
        System.out.println(2<<3);//16
    

包机制

1. 包语句的语法
   • package pkg1[.pkg2 [. pkg3…]];
2. 导包
   0000 0101 5
   0000 0110 6
   0000 0111 7
   0000 1000 8
   0000 1001 9
   0000 1010 10
   0001 0000 16
   */
   System.out.println(2<<3);//16

#### 包机制

1. 包语句的语法
   - package	pkg1[.pkg2 [. pkg3...]];
2. 导包
   - import	package1[.package [. package...]].(classname|*);