【格拉365天不摆烂行动】尚硅谷Java基础.md

非教程, 知识点笔记.

第一章:概述

• 多行注释不能包括多行注释

• 编写: 我们编写的java代码保存在'.java'结尾的源文件中

• 编译: 使用java.exe命令编译java源文件

• 运行: 使用java.exe解释运行我们的字节码文件

• 在一个Java源文件中可以有多个class, 但是只能一个声明public

• 面向对象封装性内容, public 表明的是说明的class的权限大小~而且声明为public类的类名必须与源文件名相同

• 程序的入口是main()方法.格式是固定的

// 几个位置~ 可以变化
// 1. String的[]可以放在 args后面
// 2. args 是个参数名 可以改名~
pubilc class Hello {
  public static void main(String[] args){
    System.out.printIn("Hello World");
  }
}

输出语句:

• System.out.printIn() 先输出后换行

• System.out.print() 输出完不换行

• 记得分号...

• 也有空写print语句代表换行的// python也有

• Java没有indention严格

运行

• 运行时候运行带main函数的class文件.

题

• JDK = JRE + Java的开发工具(javac, java, javadoc)
• JRD = JVM + Java的核心类库

第二章 基础

关键字保留字

• 关键字所有字母都小写
• 保留字: 就是未来可能使用, 所以不让你用~

标识符: 自己取名的都叫标识符

• 26个字母+$符+_+0-9组成
• 数字不可以开头
• 不可以使用关键字保留字,但是可以包含
• 严格区分大小写,长度不限制
• 不能包含空格

变量

class VariableTest{
    public static void main(String[] agrs){
        int myAge = 23;
        System.out.println(myAge);
    }
}

• 变量必须先赋值再使用(js ES5用var 会存在变量提升,所以不需要)
• 变量声明后 还需要初始化(就是第一次赋值的意思)(js会为undefined, 也是之前~)

如何判断编译错误还是运行错误

• 在使用IDEA的时候, 不需要执行就可以接受到的错误就是编译错误, 运行错误一般需要运行后才知道, 一般为逻辑错误, 异常等.
• 先使用再赋值会编译不过

基本数据类型

整型

• byte 8位 二进制补码 带符号 -128~127
• short 16位
• int 32位
• long 64位 最后要带L 小写也可以

浮点型

• float 单精度 32位 0.0f
• double 双精度 64位 0.0d

布尔

• boolean

字符

• char 单一的16位Unicode字符

ASCII 码 比较早的编码方式

Unicode 一次迭代更新

UTF-8 是Unicode广泛实现

基本数据类型之间的运算规则(不包含布尔)

long 都没float型范围大~底层存储不一样

自动类型提升

class VariableTest{
    public static void main(String[] agrs){
        byte b1 = 2;
        int i1 = 12;
        int b2 = b1+i1;
        // 报错 精度丢失
        // byte b2 = b1+i1;
        System.out.println(b2);
      short q1 = 10;
      long s1 = q1;
      System.out.printIn(s1)
    }
}

• 容量小的和容量大的运算, 结果自动转换为容量大的
• char 和 int 做运算是 int
• short 和 char 运算是 int

byte / char /short -->int --> long --> float --> double

• 当byte char short做运算时, 至少是int~如果用小的就会报错.

Java在做运算时, 如果运算范围在int内 都用int表示.

强制类型转换

• 转换符(): (int) 12.9

强制类型转换, 可能导致精度丢失

整型常量 默认为int

浮点型常量 默认为double

class VariableTest{
    public static void main(String[] agrs){
        // 1.编码情况1
        long a = 123123;
        System.out.println(a);//没写l 这个时候按int执行的a
        // 编译失败
        // float f1 = 12.3 // 不写f直接失败

        // 2. 编码情况2
        byte b = 12;
//        byte b1 = b+1; // int 转byte 丢失
//        float f1 = b + 12.3; // 12.3是double 没有强制转换就会编译失败
        
    }
}

字符串类型: String(引用数据类型) 非基本数据类型

char a ="" 报错: 空字符文字

String s = "" 没问题

• String可以和8种基本类型做运算.
• 运算结果仍然是String

运算符

算术运算符

4. /
5. %
6. ++
7. --

赋值运算符

=

+=, -=,*=,/=,%=

比较运算符

1. ==
2. !=
3. <
4. >
5. <=
6. >=

instanceof

用来判断是否是类的对象

1. 逻辑运算符
2. 逻辑与 &
3. 短路与&&
4. 逻辑或|
5. 短路或||
6. 逻辑非!
7. 逻辑异或^

异或是 ab不同为ture

位运算符(跳过了~)

三元运算符

(condition) ? expression1: expression2

运算符优先级

一般都加括号..

Scanner

判断基本数据类型

public class test {
 public static void main(String[] args){
  test t=new test();
  int int_num=0;
  double double_num=0;
  System.out.println(t.judgeType(int_num));
  System.out.println(t.judgeType(double_num));
 }
 public boolean judgeType(Object temp){
  if(temp instanceof Integer)
   return true;
  else 
   return false;
 }
}

public class test {
 public static void main(String[] args){
  try{
   Scanner input=new Scanner(System.in);
   int i=input.nextInt();
   System.out.println("输入正确");
  }
  catch(Exception e){
   System.out.println("输入错误");
  } 
 }
}

If-else 跳过

switch-case

Switch 中的表达式只允许是以下六种数据类型: byte, short, char, int, 枚举类型enum 和 String类型

主要是注意 case age>18:

age>18 返回布尔值

布尔值和其他类型无法比较~

• case之后只能声明常量, 不能声明范围

• default 是默认执行,位置还很灵活. 并且可选的

• 所有的switch-case都可以转换成if-else

循环(跳了)

break和continue使用

break: 循环中和switch-case 中

continue: 在循环中

....

还有个带label标签的break使用

用法 label:for...{

...

break label;

}

第三章 数组

1. Array 是多个相同数据类型按一定顺序排列的集合, 并使用一个命名, 通过编码方式对这些数据进行管理

特点

• 有序排列的
• 数组属于引用类型的变量. 数组的元素可以是基本数据类型也可以是引用数据类型
• 创建数组对象会在内存中开辟一块连续的空间
• 数组长度一旦固定,就不能修改

一维数组

class Test {
    public static void main(String[] args) {
        // 声明和初始化
        int[] ids;
        // 静态初始化:数组的初始化和数组元素的赋值操作同时进行
        ids = new int[]{1001,1002,1003,1004};
        // 动态初始化:数组的初始化和数组元素的赋值操作分开进行
        String[] names = new String[5];

        // 如何调用数组的指定位置的元素

        names[0] = "Shinkai";
        names[1] = "Shinkai";
        names[2] = "Shinkai";
        names[3] = "Shinkai";
        names[4] = "Shinkai";
//        names[5] = "Shinkai"; // 数组越界是运行报错~编译可以通过.
        // 字符串用 charAt(0)方法

        // 如何获取数组的长度
        System.out.println(names.length);//5
        System.out.println(ids.length);//4
        // 如何遍历数组
        for(int i=0;i<names.length; i++){
            System.out.println(names[i]);
        }
        
    }
}

class Test {
    public static void main(String[] args) {
// 数组元素的默认初始化值:
        // 整型 是0
        // 浮点型 是0.0
        // char 是 '\n0000' 非真实0
        // 布尔是 false
        // String 是null null是关键字
        String[] ids = new String[5];
        ids[0]= "true";
        for (int i = 0; i < ids.length; i++) {
            System.out.println(ids[i]);
        }

    }
}

二维数组

其实没有二维数组~ 只不过是在一维数组里存了另外的一维数组.

二维数组是抽象出来的~

class Test {
    public static void main(String[] args) {
        // 1.二维数组初始化
        int[][] arr = new int[][]{{1, 2, 3}, {4, 5}, {6, 7, 8}};
        // 动态初始化1
        String[][] arr1 = new String[3][2];
        // 动态初始化2
        String[][] arr2 = new String[3][];
        int[] arr3[] = new int[][]{{1, 2, 3}, {4, 5}, {6, 7, 8}};
        int[] arr4[] = {{1, 2, 3}, {4, 5}, {6, 7, 8}};
        int  arr5[][] = {{1, 2, 3}, {4, 5}, {6, 7, 8}};
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.println(arr[i][j]);
            }
        }
    }
}

类型推断~

int[] arr4 = new int[]{1,2,3,4,5};
int[] arr5 = {1,2,3,4,5}; // 类型推断

数组方法

boolean equals(int[] a , int[]b ) 判断数组相等

String toString(int[] a)

void fill(int[]a, int val)

void sort(int[] a)

int binarySearch(int[] a, int key)

常见异常

• 交表越界
• 空指针异常

---

时间有限只放知识点了

第四章:面向对象

• Java类以及类的成员: 属性, 方法, 构造器, 代码块, 内部类
• 面向对象三大特性: 封装性, 继承性, 多态性,(抽象性)
• 关键字: this, super, static, final, abstract, interface

类和对象

• 类: 抽象概念的人~
• 对象: 实例化类~ 实实在在的人~
• 面向对象的重点就是类的设计
• 类的设计其实就是类的成员的设计: 属性方法构造器,代码块,内部类

属性 = 成员变量 = 字段field = 域

方法 = 成员方法 = 函数 = method=行为

class Person {
    String name;
    int age;
    boolean isMarried;

    void walk(){
        System.out.println("walk");
    }
    String display(){
        return "名字是"+name+",年龄是"+age;
    }
};
class Test{
    public static void main(String[] args) {
        Person person = new Person();
        person.name = "Shinkai";
        person.age = 23;
        System.out.println(person.display());;
    }
}

创建类的对象 = 类的实例化 = 实例化类

类和对象的使用

1. 创建类, 设计类的成员变量 成员方法(构造函数, 代码块,内部类)
2. 实例化类
3. 通过对象.属性/对象.方法使用

多个类的对象的关系

每个类的对象在内存中都存在不同的位置~

只要new一下, 就分配给新的地址~

类的对象之间存在不同的堆地址里

堆(heap)和栈(stack)

• 堆的唯一目的就是存放对象实例
• 几乎所有的对象实例都在堆里分配内存(jvm规范相关)
• 栈一般指 虚拟机栈 储存局部变量等. 基本数据类型和地址值,也就是对象的引用.执行完自动释放
• 方法区, 用于存储 类信息, 常量, 静态变量, 即时编译器编译后的代码等

属性(成员变量)vs局部变量

相同点:

1. 数据类型 变量名 = value;
2. 先声明后使用
3. 都有scope作用域

不同点:

1. 在类中位置不一样
2. 属性直接在{}内;
3. 局部变量在方法内,形参内,代码块内, 构造函数形参, 构造器内部变量
4. 权限修饰符不同
5. 属性: 在声明属性时候,指明其权限, 权限修饰符
6. 常见的权限修饰符: private, public, default, protected.
7. 属性可以全部用default~
8. 局部变量不能使用权限修饰符

默认初始化

• 整型(byte/short/int/long) 0
• 浮点型(float/double) 0.0
• 字符型(char) 0;\u0000
• 布尔型(boolean) false
• 引用数据类型(类数组接口)null

局部变量没有默认初始化值, 意味着调用之前,必须要声明,特别的~ 形参是调用时候赋值~不是之前

- END -