学习笔记Java基础知识笔记

Posted 2021-06-16 棉花糖灬

• 八大基本类型：boolean/short/char/int/long/float/double，Integer是int的包装类，必须实例化后才能使用。注意String类型不是基本类型。
• instanceof运算符左边是一个对象，右边是一个类，当组左边的对象是右边类或子类创建的对象时返回true，反之为false。
• 一个分号也是一条语句，称作空语句。
• javac 文件名.java：编译java文件，java 文件名：运行java文件

import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        System.out.println("请输入一个浮点数：");
        // 输入数据
        Scanner reader = new Scanner(System.in);
        // reader还有nextBoolean/nextByte/nextShort/nextInt/nextLong/nextFloat等方法
        double x = reader.nextDouble();
        //if - else if - else 的使用
        if (x > 1.0) {
            // 输出时可以直接使用+x将变量x转换为string类型
            System.out.println("x: " + x + ">1.0");
        } else if (x < -1.0) {
            // 也可以采用和C语言中相似的输出方式，注意是printf
            System.out.printf("x: %f\\n", x + "<-1.0");
        } else {
            System.out.println("x: " + x);
        }
        // for循环的使用
        for (int i = 0; i < 5; i++) {
            System.out.print(i + " ");
        }
        System.out.println();
        // while循环的使用
        int j = 0;
        while (j < 5) {
            System.out.print(j++ + " ");
            if (j == 2) continue;
            if (j == 4) break;
        }
        System.out.println();

        // 一次声明2个数组，也可以声明为a[]，但不推荐
        // 在声明数组的同时赋值，也可以单独赋值，如c[0]=1;
        float[] a = {1, 2, 3, 6}, b = {2, 4, 6};
        // 二维数组中每个一维数组的长度可以不同
        char[][] c = {{'a', 'b', 'c'}, {'2', '6'}};
        // 数组的长度
        System.out.println("c[1].length: " + c[1].length);
        // 遍历数组的一种便捷方式
        for(float y:a){
            System.out.println(y+" ");
        }
        System.out.println();
    }
}

• java中有两种多态：重载（overload）和重写（override），重写是与继承有关的多态。
• 重载的含义是一个类中可以有多个具有相同名字和返回值类型的方法，但参数列表必须不同
• 用private修饰的成员变量和方法称为私有变量和私有方法，类的对象不能直接访问私有变量和私有方法。
• 用public修饰的成员变量和方法称为共有变量和共有方法，可以在另一个类中用该类的对象访问变量和方法。
• 用protected修饰的成员变量和方法称为受保护变量和受保护方法。
• 不用private/public/protected修饰的成员变量和方法被称为友好变量和友好方法，不在同一个包中的该类的对象不能访问变量和方法。
• Object类是所有类的祖先类，访问限制修饰符private/protected/public在继承时会起到作用。

// 包声明语句必须放在java源文件的第一句，不同包下的类可以重名
// 在运行时必须到com的父目录下运行java com.ecnu.Test，编译时都可
package com.ecnu;

import java.util.Scanner;


public class Test {

    // 类成员变量有默认值，如下面的m的默认值为0，而局部变量无默认值
    int x = 5, n = 10, m;
    // 有static修饰的是类变量，又称静态变量，其他的称为实例变量
    // 不同对象的实例变量不同，但共享静态变量，还可以通过类名直接访问静态变量，如Test.y
    static int y = 11;
    // 这一句是错误的，因为对变量的操作只能写在方法中
    // m=15;

    // 构造方法是和类名完全相同且没有返回类型的方法，可以有多个构造方法，但必须保证参数个数或参数类型不同
    // 构造方法在创建对象是会被执行，如果无构造方法，系统会调用默认的构造方法，默认构造方法无参数且方法体为空
    Test() {
        // this表示当前对象，可以出现在实例方法和构造方法中，但是不可以出现在类方法中
        // 用this访问对象的属性和方法，一般可以省略，但当局部变量和成员变量重名时不可省略
        this.getSum(this.n);
        System.out.println("构造方法被执行了。。。");
    }

    // 类中的方法
    int getSum(int n) {
        int sum = 0, x = 10;
        for (int i = 0; i < n; i++) {
            sum += i;
        }
        // 如果类方法中的变量名和类成员变量名冲突时，使用this.变量名访问类成员变量
        System.out.println("this.x: " + this.x + "  x: " + x);
        return sum;
    }

    // 重载（overload）：方法名和返回值类型相同，参数列表不同
    int getSum(int n, int m) {
        return m;
    }

    // 可以从某项参数开始直到最后一项使用...表示多个参数，但参数的类型必须相同，个数不确定
    // 访问限制修饰符 返回值类型 方法名(参数列表)
    // 访问限制修饰符有private/protected/public
    public void func(double a, int... x) {
        // 使用增强的for语句遍历参数列表
        for (int y : x) {
            System.out.print(x + " ");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        // 创建对象
        Test test = new Test();
        // 对象数组，一次声明多个对象，在使用时必须用new创建对象
        Test[] test_lst = new Test[3];
        test_lst[0] = new Test();
        // 访问对象的属性
        System.out.println("test.n: " + test.n);
        // 访问对象的方法
        System.out.println("sum: " + test.getSum(10));
    }
}

• 用extends关键字进行类的继承，当子类中有和父类中同名的变量时，父类中的变量就被隐藏了，但是可以通过super关键字访问父类的变量，子类不继承父类的构造方法，可以使用super();来调用父类的构造方法。
• 方法重写（方法覆盖）可以隐藏已继承的方法，要求方法类型是父类方法的子类或与其一致，方法名、参数个数、参数类型完全相同。当返回值不一样或不是父类方法的子类，但方法名、参数个数、参数类型完全一样时，会产生编译错误。重写时不允许降低方法的访问权限，但可提高访问权限。
• 使用关键字final声明一个最终类，final类不能被继承；final方法不允许被子类重写；用final修饰的变量即常量。
• Animal a = new Tiger(); 被称为上转型对象，其中Tiger是Animal的子类。上转型对象不能操作子类新增的成员变量，不能调用子类新增的方法。
• 多态是指父类中的某个方法被子类重写时，可以各自产生自己的功能行为。
• 使用abstract关键字修饰的类/方法成为抽象类/方法，抽象方法只允许声明，不允许实现，即没方法体。final和abstract、static和abstract不能同时使用。非抽象类中不能有抽象方法。不能使用new来创建抽象类的对象，如果一个非抽象类是一个抽象类的子类，那么它必须实现父类的所有抽象方法。

package com.ecnu;

// 接口类应被其他类使用implements实现，如class A implements Printable, Addable
// 并且实现类一定要重写接口方法，否则就是抽象类，重写时方法一定是public的，因为访问权限不能降低
// 接口回调是指把实现类创建的对象赋值给其接口类声明的对象，如 ITest test = new Test();
// 接口的多态是指不同类在实现同一接口时可能具有不同的实现方式
// 接口类与抽象类的不同：接口类中不可以有变量，抽象类中可以；抽象类也可以有非抽象方法，接口类中不可以
public interface ITest {
    // 接口体包括常量声明和抽象方法两部分，没有变量
    // 省略了public static
    final int x=100;
    // 省略了public abstract
    void add();
    float sum(float x,float y);
}

• 类中的类被称为内部类，包含内部类的类叫做外嵌类。
  • 外嵌类的成员变量在内部类依然有效，内部类中的方法也可以调用外嵌类中的方法；
  • 内部类可中不可以声明类变量（静态变量）和类方法（静态方法），外嵌类中可以用内部类声明对象；
  • 内部类仅提供给它的外嵌类使用；

// 创建子类对象时，除使用父类的构造方法外还有类体，此类体被认为是一个子类去掉类声明后的类体，称为匿名类
// 匿名类可以继承或重写父类的方法，匿名类一定是内部类
// 匿名类是一个子类，但没有类名，所以用匿名类创建对象时，要直接使用父类的构造方法
// Bank是类，以下代码是用Bank的一个子类（匿名类）创建对象
new Bank(){ 
    
};
// java允许直接用接口名和类体创建一个匿名对象，Computable是接口名
new Computable(){
    // 实现接口的匿名类的类体
};

// 使用try-catch来处理异常，将可能出现异常的操作放在try部分，一旦产生异常则try部分立即停止，
// 转而执行catch部分，所有的异常类都是Exception的子类
try{
    int i=1;
    int j=1/0;
}catch(异常子类1 e){
    
}catch(异常子类2 e){
    
}
// 一个方法在声明时可以使用throws来声明要产生的若干个异常，然后在类体中用相应的异常类创建对象，
// 并使用throw抛出该异常对象，导致该方法执行结束。catch的作用就是捕获throw抛出的异常对象

// 断言，当number>=0条件满足时程序继续执行，反之立即结束执行并输出冒号后面的提示信息（可没有）
assert number>=0:"不能为负数";
assert number>=0;