2021-07-07 17:34 中国科学院大学 Java

关注

手把手从零开始学习JAVA（入门基础）

1、搭建JAVA开发环境

卸载JDK（未安装的请忽略）

将JDK的安装目录删除
删除JAVA_HOME以及CLASS_PATH 环境变量
删除PATH下与JAVA_HOME以及CLASS_PATH有关的环境变量

安装JDK

去Oracle官网下载JDK或者去一些国内镜像网站下载JDK安装文件
将JDK安装到本机中
新增环境变量JAVA_HOME，指定路径为JDK的安装目录
更新环境变量PATH，加入%JAVA_HOME\bin%、以及%JAVA_HOME\jre\bin%
打开电脑DOS命令窗口，输入java -version以及javac命令判断java环境是否安装完毕

2、编程语言中，何为编译型与解释型

编译型

使用专门的编译器，针对特定的平台，将高级语言源代码一次性的编译成可被该平台硬件执行的机器码，并包装成该平台所能识别的可执行性程序的格式。可以理解为有一个解释器，将所有的源代码编译成了硬件可以执行的机械码并直接执行，运行期间无需再次编译（速度快）

解释型

使用专门的解释器对源代码逐行编译成特定的硬件可执行的机械码并且直接执行

3、第一个JAVA应用程序

// 在dos命令行执行 javac HelloJava.java
// 执行 java HelloJava
// 输出结果：Hello JAVA
public class HelloJava{
public static void main(String[] args){
     System.out.println("Hello JAVA");
  }
}

4、JAVA之中的关键字有哪些

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   short   static   strictfp 
super   switch   synchronized   this   throw   throws 
transient   try   void   volatile   while

5、注释的使用

// 这是一个单行注释
/*
  这是一个多行注释，我是第一行
  这是一个多行注释，我是第二行
*/

/**
  这是一个DOC文档注释
*/

6、标识符的定义规则

  //JAVA中定义的标识符只能是 字母[a-z][A-Z]、下划线_、美元符号$ 开头
  // 正确实例
  int name;
  int Name;
  String _str;
  String $str;

  // 错误示例
  int *1;
  int #1;

7、基础数据类型规则

JAVA的8个基础数据类型

  /**
    位bit是计算机最小的存储单位
    1个字节byte 占据8位，也就是1byte = 8bit
  */
  // 整数类型 
  byte 占据1个字节，范围为2^7 到 (2^7)-1
  short 占据2个字节
  int 占据4个字节
  long 占据8个字节
  // 浮点类型
  float 占据4个字节
  double 占据8个字节
  // 字符类型

  char 占据2个字节
  // 布尔类型，值只有true或false
  boolean 占据1位

数据类型面试题

银行金额需要使用什么数据类型
BigDecimal 类来存储金额
为什么浮点数不能用来计算金额
因为不够精确，会损失精度

基础数据类型转换规则

自动转换规则
向上转型，意思就是精度小的会向着精度大的进行转型，long与double进行运算后结果为double。
强制转换规则

  // 在需要强制转换的变量前加入小括号 (数据类型)[变量名]
  // 只有向下转型时需要使用强制转换（意思就是精度大的转换为精度小的需要强制转换）
  // 强制转换时要注意丢失精度问题
  long long1 = 10;
  int int1 = (int)a1;

变量、常量、作用域

  // 局部变量的作用域仅限于当前方法
  // 成员变量只有创建了该类的实例才能使用
  // 类变量用类即可调用，作用于当前类

  // 使用了final修饰的变量就会变成一个常量
  // 变量，顾名思义，可以被多次重新赋值的一个值

算数运算符

自增自减运算符

  int a = 10;
  int b = a++; // 先赋值再加1，值为10，该行结束后a为11
  int c = ++a； // 先加1再复制，值为12

与或非运算符

  // 与 &&，两个都为true才为true， && 为断路与，只要左边为false，右边则不进行判断了
  // 或 ||，两个都为false才为false，否则为true
  // 非 ! ，将false取反为true，将true取反为false

位运算符 & | ^ ~ << >> >>>

  & | ^ ~
  /*
    计算机底层在运算时，会将其转换为补码形式
    1、正数的补码等于它的原码
    2、负数的补码等于它的原码 （取反 +1） , 而负数的补码转换为原码的时候则需要 （-1 取反）也就是逆运算
    3、补码与原码之间的转换时，最高位符号位不用取反
    4、使用~进行取反的时候，符号也要取反
    5、左移右移时记住一点细节，5>>3 = 5/(2^3) ，5<<3 = 5*(2^3) 
  */
  // 位运算的应用1：判断奇数偶数，一个数 &1，如果结果为1则是奇数，否则为偶数
  int num = 10;
  String result = (num & 1)==0 ? "偶数" : "奇数";
  /*
    位运算的应用2：使用异或^完成两个数之间的值交换
    原理：一个数异或自己，再异或一个其他的数，就会变成那个其他的数，例如： 5 ^ 5 ^ 8 = 8，因为5^5之后结果得0，所以再^8时结果为8
    两个数字a与b进行交换，a = a^a^b，b = b^b^a；可以看到一个规则，其中两个等式右边都有一个 a ^ b
 
  */
  int a = 10;
  int b = 20;
  // 由于等式右边都有一个a ^ b
  a = a ^ b;
  // a 等于了 a^b时，b只需要用自己 ^ 一次a 就可以得到a的值
  b = b ^ a;
  // 而这个时候 a只需要再^一次自己当初的值即可得到b的值，自己的当初的值已经赋值给了b，所以再^ 一次b即可
  a = a ^ b;
  System.out.println("这时a的值等于：" + a + " b的值等于：" + b);

javadoc生成java文档

  @author 作者名
  @version 版本号
  @since  指明最早使用的jdk版本
  @parram 参数名
  @return 返回值
  @throws 所抛出的异常

  生成javadoc时，需要使用的命令： javadoc -encoding utf-8 -charset utf-8

流程控制

switch

  // switch语句中只能编写byte、short、int、char，在jdk1.7时可以使用String

递归思想

  递归就是方法自己调用自己，但是递归调用的空间复杂度较高，容易出现栈溢出
  例如使用递归编写一个可以计算出阶乘的
  
  public int factorial(int baseNum) {
    if (baseNum == 1){
      return 1;
    }else {
      return baseNum * factorial(baseNum - 1);
    }
  }

java内存栈、堆、方法区、常量池

栈

存放对象的引用（地址）
存放基本类型的变量（包括值）

堆

存放new出来的对象及数组

方法区

存放所有的class文件
存放static修饰的方法及其变量

数组的三种初始化及基本特点

静态初始化

int[] arr1 = {1,2,3,4};
String[] arr2 = {new String("s1"),new String("s2")};

动态初始化（包含默认初始化，及对应的数据类型的默认值）

int[] arr2 = new int[10];

数组的基本特点

数组长度一旦确定就不能够改变
数组只能是固定类型，不能为混合类型（数组中的每个元素都必须为相同类型）
数组中的元素可以是基本类型，也可以是引用类型
数组创建出的对象存放在堆中，引用存放在栈中
并且数组本身即为一个对象

关于二维数组的理解

可以理解为一个数组里装了多个一维数组

数组的选择排序与冒泡排序

  // 冒泡排序
  public static void bubbleSort(int[] arr) {
        // 确定循环次数
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if(arr[i] < arr[j]){
                    // 交换
                    arr[i] = arr[j] ^ arr[i];
                    arr[j] = arr[j] ^ arr[i];
                    arr[i] = arr[j] ^ arr[i];
                }
            }
        }
    }

  // 选择排序
  public static void selectSort(int[] arr) {
        // 确定循环次数
        for (int i = 0; i < arr.length - 1; i++) {
            // 每次循环都需要得到一个最大或最小的值
            for (int j = i + 1; j < arr.length; j++) {
                if(arr[i] < arr[j]){
                    // 交换
                    arr[i] = arr[j] ^ arr[i];
                    arr[j] = arr[j] ^ arr[i];
                    arr[i] = arr[j] ^ arr[i];
                }
            }
        }
    }

权限修饰符

  权限修饰符       本类       当前包      不同包下的子类      不同包
    private        √
  default(默认)     √           √
   protected       √           √              √
    public         √           √              √              √

多态中、方法的编译看左边，运行看右边，变量的编译与运行都看左边

记住一点，static修饰的方法不能被重写，所以调用static修饰的方法，编译运行都看左边，而变量无法被重写，所以编译运行也都看左边

public class A {
    public static void main(String[] args) {
        Father father = new Son();
        System.out.println(father.a);
        System.out.println(father.b);
        father.show();
        father.staticShow2();
    }
}

class Father{
    int a = 10;
    static int b = 20;
    public void show(){
        System.out.println("父类的成员方法");
    }

    public static void staticShow2(){
        System.out.println("父类的静态方法");
    }
}
class Son extends Father{
    int a = 100;
    static int b = 200;
    @Override
    public void show(){
        System.out.println("子类的成员方法");
    }
    public static void staticShow2(){
        System.out.println("子类的静态方法");
    }
}