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
发布评论