最新消息:XAMPP默认安装之后是很不安全的,我们只需要点击左方菜单的 "安全"选项,按照向导操作即可完成安全设置。

java基础知识点总结分享

XAMPP相关 admin 230浏览 0评论
es0008
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)这种深度递归

版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。

本文链接:https://blog.csdn.net/BLU_111/article/details/108034379

转载请注明:XAMPP中文组官网 » java基础知识点总结分享