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)这种深度递归

更多推荐

java基础知识点01