java基础知识点01

曾经终败给现在 2022-11-27 15:53 246阅读 0赞

**java基础知识点01**

--------------------

**java三大版本**

JavaSE 标准版（桌面程序，控制台）  
JavaME 嵌入式开发（小家电）  
JavaEE 企业级开发（web端，服务器开发）

**JDK：** Java Development Kit  
**JRE：** Java Runtime Environment  
**JVM：** Java Virtual Machine

**Java安装和卸载：**

*  卸载JDK：  
    删除java安装目录 —> 删除环境变量JAVA\_HOME —> 删除Path中的JDK和JRE —> java -version命令检查
 *  安装JDK：  
    安装JDK程序 --> 添加环境变量（java安装路径）JAVA\_HOME —>  
    Path中添加JDK和JRE路径（%JAVA\_HOME%\\bin 和 %JAVA\_HOME%\\jre\\bin）—>  
    java -version命令检查

**入门程序Hello.java：**

public class Hello{ 
    	public static void main(String[] args){ 
    		System.out.print("Hello, BLU!");
    	}
    }

**编译命令：**  
编译java文件（将java文件编译成字节码文件Hello.class）

javac Hello.java

**运行命令：**

java Hello

Java拥有**编译型**和**解释型**两种特点  
**编译型**：将《三体》整本翻译给美国人看  
**解释型**：美国人看到哪翻译官就翻译到哪

**Java程序运行机制：**

*.java源程序经编译器javac.exe编译为字节码文件*.class（二进制字节码文件，相当于JVM的机器语言）
    *.class文件通过类装载器进入JVM (将类文件读入到内存，并创建java.lang.Class对象)
    通过字节码校验器校验错误（校验器负责检查那些指令无法执行的明显有破坏性的操作。）
    把每一条要执行的字节码交给解释器java.exe，翻译成对应的机器码，由解释器执行。

**字节码校验器的检查：**

变量要在使用之前进行初始化。
    方法调用与对象引用类型之间要匹配。
    访问私有数据和方法的规则没有被违反。
    对本地变量的访问都在运行时堆栈内。
    运行时堆栈没有溢出。

**java注释：**

//单行注释 Line Comment
    
    /* 多行注释 Block Comment */
    
    /** * @Description 文档注释 * @Author 作者名 * @Version 版本号 * @since 最小jdk版本 * @param 参数名 * @return 返回值情况 * @throws 异常抛出情况 * */

javadoc命令生成开发文档的示例：

javadoc -encoding UTF-8 -charset UTF-8 Doc.java

**java基本数据类型：**  
java属于强类型语言（变量必须先定义后使用）

八大基本数据类型：
    	整数类型：byte	1个字节	-128 ~ 127
    	整数类型：short	2个字节	-32768 ~32767
    	整数类型：int	4个字节	-2147483648 ~ 2147483647
    	整数类型：long	8个字节	-9223372036854775808 ~ 9223372036854775807
    	
    	浮点数类型：float	4个字节	精度为6~7位有效数字
    	浮点数类型：double	8个字节	精度为15~16位有效数字
    
    	字符类型：char	2个字节	只能存一个字符
    	布尔类型：boolean	占1位	只有true和false两种取值
    
    注：java中用L结尾表示long类型，用F结尾表示float类型。
    long num1 = 30L;
    float num2 = 30.5F;
    
    整数扩展：
    十进制：int i = 10;
    八进制：int i2 = 010;
    十六进制：int i3 = 0x10;
    
    浮点数扩展：
    float f1 = 0.1f;
    double d1 = 1.0/10;
    System.out.println(f1==d1);	结果为false
    
    float f2 = 293793761876186913f;
    float f3 = f2 + 1;
    System.out.println(f2==f3);	结果为true
    
    原因是浮点数类型的数据精度是有限的，存在舍入误差的问题，不能精确地表示一个数。
    避免使用浮点数进行比较和计算，银行使用BigDecimal类来表示钱。
    
    字符扩展：
    字符类型可强制转换为int类型，值为字符在ASCII码表中的编号：
    char c1 = 'a';
    char c2 = '中';
    System.out.println((int)c1);	结果为：97
    System.out.println((int)c2);	结果为：20013
    
    String扩展：
    String s1 = new String("BLU");
    String s2 = new String("BLU");
    String s3 = "BLU";
    String s4 = "BLU";
    System.out.println(s1==s2);	结果为：false		堆内存地址不同
    System.out.println(s3==s4);	结果为：true		属于同一个常量池

**Java类型转换：**  
**Byte → short → int → long —› float → double  
char → int**  
自动类型转换：低转高  
强制类型转换：高转低

自动转换案例一：
    int i = 128;
    double b = i;
    System.out.println(b);	结果为：128.0
    
    自动转换案例二：
    char c = 'a';
    int i = c+1;
    System.out.println(i);	结果为：98
    
    强制转换案例一：
    int i = 128;
    byte b = (byte) i;
    System.out.println(b);	结果为：-128	内存溢出
    
    强制转换案例二：
    System.out.println((int)23.7);		结果为：23		丢失精度
    System.out.println((int)-45.89f);	结果为：-45		丢失精度
    
    强制转换案例三：
    char c = 'a';
    int i = c+1;
    System.out.println((char)i);	结果为：b

**java变量和常量：**

常量：初始化后不能修改值，用final修饰
    
    变量作用域：
    1. 类变量（静态变量），定义在类中，必须用static修饰，所有对象共有
    2. 实例变量，定义在类中，没有static修饰，属于对象私有
    3. 局部变量，有效期在本方法内
    
    public class Snippet { 
    
    	final static double PI = 3.14;	//常量
    	static int a=0;		//类变量
    	String b = "BLU"; 	//实例变量
    	
    	public static void main(String[] args) { 
    		int i = 0;	//局部变量
    	}
    
    	public void add(){ 
    	
    	}
    	
    }
    
    变量命名规则：
    见名知意
    变量和方法名：首字母小写和驼峰原则		nickName	transMoney()
    常量：用大写字母和下划线_分隔符		PI	MAX_VALUE
    类名：首字母大写和驼峰原则			UserOrders

**java运算符：**

算数运算符：	+  -  *  /  %  ++  --
    赋值运算符：	=
    关系运算符：	>  <  >=  <=  ==  !=  instanceof
    逻辑运算符：	&&  ||  !
    位运算符：		&  |  ^  ~  >>  <<  >>>
    条件运算符：	?  :
    扩展赋值运算符：	+=  -=  *=  /=
    
    运算符实例1：
    long a = 1000000000000000L;
    int b = 100;
    short c = 10;
    byte d = 1;	
    System.out.println(a+b+c+d);	long类型
    System.out.println(b+c+d);		int类型
    System.out.println(c+d);		int类型
    
    运算符操作数中有1个为long类型，则结果为long类型，操作数中没有long，则结果为int
    
    运算符实例2，自增自减运算符：
    int a = 1;
    int b = a++;
    int c = ++a;
    System.out.println(a);		结果为：3
    System.out.println(b);		结果为：1
    System.out.println(c);		结果为：3
    
    a++为先赋值再自增，++a为先自增再赋值
    
    运算符实例3，逻辑运算符的短路运算问题：
    int c = 5;
    boolean d = (c<4)&&(c++<4);
    System.out.println(c);		结果为：5
    System.out.println(d);		结果为：false
    
    如果已经在逻辑运算符的左边得出了整个表达式的结果，则不会计算右边表达式
    
    运算符实例4：
    int a = 10;
    int b = 20;
    System.out.println(""+a+b);		结果为：1020
    System.out.println(a+b+"");		结果为：30
    
    当字符串连接+号时，+号为字符串拼接符

**java方法（形参和实参）：**

public class demo01 { 
    
    	public static void main(String[] args) { 
    		//实际参数，调用方法时实际传递的参数
    		int sum = add(1,2);
    		System.out.println(sum);
    	}
    	
    	//形式参数，定义方法时用于接收值的参数
    	public static int add(int a, int b) { 
    		return a+b;
    	}
    	
    }

**方法的重载（在同一个类中，函数名称相同但形参不同的函数）：**

public class demo01 { 
    
    	public static void main(String[] args) { 
    		int sum = add(1,2);
    		double sum2 = add(1.0,1.5);
    		int sum3 = add(1,2,3);
    		System.out.println(sum);
    		System.out.println(sum2);
    		System.out.println(sum3);
    		
    	}
    	
    	public static int add(int a, int b) { 
    		return a+b;
    	}
    	
    	public static double add(double a, double b) { 
    		return a+b;
    	}
    	
    	public static int add(int a,int b,int c) { 
    		return a+b+c;
    	}
    	
    }

**命令行传参：**

public static void main(String[] args) { 	
    	for(int i=0; i<args.length;i++) { 
    		System.out.println("args["+i+"]:"+args[i]);
    	}	
    }
    
    编译命令：javac demo01.java
    运行命令：java com.blu.test.demo01 1 2 3 4 5
    运行结果：
    args[0]:1
    args[1]:2
    args[2]:3
    args[3]:4
    args[4]:5
    注：要在正确的路径下执行才可以，执行带上包名，用空格分隔传参

**可变参数：**

一个方法只能指定一个可变参数，且必须是最后一个参数
    public class demo01 { 
    
    	public static void main(String[] args) { 
    		demo01 d = new demo01();
    		d.printMax(1,6,3,5,7,8,2,4);
    	}
    	
    	public void printMax(int... args) { 
    		if(args.length==0) { 
    			System.out.println("No argument");
    			return;
    		}
    		
    		int result = args[0];
    		for(int i=0;i<args.length;i++) { 
    			if(args[i]>result) { 
    				result=args[i];
    			}
    		}
    		System.out.println("The max value is "+ result);
    	}
    	
    }

**递归（方法自己调用自己）：**

死循环递归导致栈溢出异常：java.lang.StackOverflowError
    
    public class demo01 { 
    
    	public static void main(String[] args) { 
    		demo01 d = new demo01();
    		d.test();
    	}
    	
    	public void test() { 
    		test();
    	}
    	
    }
    该递归结构没有递归头（递归边界（不调用自身的条件）），因此陷入了死循环！
    
    利用递归计算阶乘：
    public class demo01 { 
    
    	public static void main(String[] args) { 
    		System.out.println(f(5));
    	}
    	
    	public static int f(int n) { 
    		if(n==1) { 
    			return 1;
    		}else { 
    			return n*f(n-1);
    		}
    	}
    	
    }
    
    计算f(5)需先调用f(4)，计算f(4)需先调用f(3)，计算f(3)需先调用f(2)，计算f(2)需先调用f(1)，f(1)返回1
    根据f(1)=1计算出f(2)的值，根据f(2)的值计算出f(3)的值，根据f(3)的值计算出f(4)的值，根据f(4)的值计算出f(5)的值。
    
    这里的递归边界为f(1)
    
    注：递归极度消耗性能，能不用递归就不用递归！没法计算f(100)这种深度递归