Java 基础知识

一、类型

public class Main {
    public static void main(String[] args) {
    int[] int01 = new int[]{1,2,3};
    System.out.println(int01[0]);
    int01[2] = 4;

    // ArrlyList
    ArrayList<String> str01 = new ArrayList<String>();
    str01.add("1");
    str01.set(0,"12");
    str01.get(0);
    str01.remove(0);
    str01.size();
    
    // HashMap
    HashMap<String,String> map01 = new HashMap<String,String>();
    map01.put("1","1");
    System.out.println(map01.get("1"));
    map01.remove("1");
    map01.forEach(( k,v) -> System.out.println(k + " " + v));
    
    // list.of
    List<String> list01 = List.of("1","2","3");
    // map.list
    Map<String,String> map02 = Map.of("1","1","2","2");
    
    }
}

 二、面向对象-构造器

// 构造器名称必须和类名一致；
// 构造器，对象创建就调用；
// 构造器没有返回值；
// 应用场景，创建对象，完成对对象成员变量(属性)的初始化赋值
// 类，默认自带一个构造器
// 如果定义一个有参数的构造器，无参的构造器就没有了。
// 如果想用无参数的构造器，必须手动写一个无参数的构造器。
// 可以Student s = new student(); s.name="xx",这样不方便，用构造器更加方便

 三、面向对象-静态变量

// 静态变量
// 静态变量属于类，不属于某个对象，只加载一份
// 实例变量属于对象，每个对象都有一份
// 静态变量在类加载时初始化，实例变量在对象创建时初始化
// 静态变量可以通过类名直接访问，也可以通过对象名访问

 

四、面向对象-静态方法

// 静态方法
// 应用场景，做了一个功能，不访问对象数据
// 静态方法可以访问静态成员，不可以访问实例成员
// 实例方法，可以访问静态成员和实例成员
// 静态方法，不可以出现this关键字
// 静态方法，不可以被重写

四、面向对象-继承

// 继承
// 1.单继承
// 2.子类继承父类，则子类会拥有父类的所有属性和方法
// 3.子类可以重写父类的方法
// 4.子类与父类，方法、属性一致，用super.调用父类的方法、属性
// 5、子访问父，先找子后找父

 

四、面向对象-重写

// 重写
// 子类重写父类方法，权限必须>=父类权限
// 重写方法必须和父类方法完全一致,包括返回值类型,方法名,参数列表
// 重写方法不能是private\final\static

五、面向对象-重写-子类调父类构造器

// 子类构造器先调用父类构造器，再调用子类构造器

 

六、面向对象-重写-构造器this, 调兄弟构造器

 this 调用兄弟构造器

this() 、super() 必须写在构造器第一行，两者不能同时出现

 

七、面向对象-多态

// 多态
// 有继承关系；重写；父类引用子类
// 多态下，不能使用子类独有方法
// 调方法，调的是子类的
// 调属性，调的是父类的
// 子类调自己独有方法，可以用强制转化
// 强制转换前，用instanceof判断类型

class Person{
    String name = "Person name";
    void run(){
        System.out.println("Person run..");
    }

}
public class Student extends Person{
    String name = "Student name";
    @Override
    void run(){
        System.out.println("Person run..");
    }

    void sleep(){
        System.out.println("sleep run..");
    }

}
class Teacher extends Person{
    String name = "Teacher name";
    @Override
    void run(){
        System.out.println("Teacher run..");
    }

    void sleep(){
        System.out.println("Teacher sleep..");
    }

}

public class Main {
    public static void main(String[] args) {
    Person t = new Teacher();
    Person s = new Student();
    t.run();
    s.run();
    System.out.println(t.name);
    System.out.println(s.name);
//    System.out.println(s.sleep()); 多态下，不能使用子类独有方法
    Student s1 = new Student();
    // 强制转换
    Student s2 =  (Student)s1;
    s1.sleep();
    // 检查类型
        if (t instanceof Person) { // 判断t是否是Person类型
            Teacher t3 = (Teacher) t;
            t3.sleep();
            }

    }
}

Teacher run..
Person run..
Person name
Person name
sleep run..
Teacher sleep..

 

八、枚举

九、抽象类

 

 

 十、接口

// 接口
// 接口中的成员变量默认是public static final的
// 接口中的成员方法默认是public abstract的
// 接口中的成员方法不能有方法体
// 接口不能创建对象
// 接口是被类实现
// 类必须重写完接口里的所有抽象方法，不然将类定义成抽象类

 

 十一、接口定义方法

default、private、static