Java基础复习(1)

复习一下Java的写法

---

面向对象

类（Class）
类是抽象的，描述一类具有相同属性和行为的对象

• 成员（对象调用）
• 静态资源（类调用）
• 构造方法（创建一个对象）

对象（Object）
类的一种实例

---

类的成员

属性

• 变量（不修饰）
• 常量（final修饰）

方法（成员函数）
代码块（创建对象时自动调用一次）

---

类的静态资源(static修饰)

可以直接使用类名来调用，如果用实例调用变量和常量则相同

• 静态常量和静态变量
• 静态方法
• 静态代码块（类的第一次加载时调用，仅一次）

---

类的构造方法

默认构造函数
隐式构造，无参构造，在无显式构造时可用

显式构造方法
自定义的构造方法，会使得默认构造失效，如需无参构造需要显式表示

其他问题

1. 由于所有类都继承了Object类，所以至少会调用两次构造函数（本类+父类）
2. 可用通过重载来实现对同一个类构建实体的不同方式（使用不同的参数，类似C++多态）

方法重载

当同名方法所传入的参数类型、数量、顺序不同时，该方法可以被重载并可以做出不同的行为，与其返回值类型无关。

访问权限修饰符

限制代码的使用范围，对项目结构进行管理

• public（可以在整个项目中使用）
• private（只能在本类中使用）
• protected（可以在所有子类和同包中使用）
• 缺省（在同包中使用）

---

基础代码

package myTest;

public class User {
    //由于构造方法重载，如有需要自行实现默认无参构造
    private User(){
        this.name="";
        this.age=-1;
    }
    //显式带参构造，private修饰，仅可本类访问
    private User(String name, int age) {
        this.name = name;
        this.age = age;
    }
    //成员变量
    public String name;
    private int age;
    //成员常量，不可修改，不唯一
    final int id=10;
    //普通代码块，方便初始化，每次创建类和对象时调用
    {
        System.out.println("Object Created");
    }
    //成员方法
    public void showName(){
        System.out.println("姓名"+name);
    }
    //静态变量，唯一
    static int num;
    //静态常量，唯一
    static final int l=100;
    //静态方法中，不能使用成员方法和成员变量，只能调用其他静态方法或静态变量和常量
    public static int min(int a,int b){
        return a<b?a:b;
    }
    //静态代码块，类第一次调用时执行，仅一次
    static{
        System.out.println("Class Created");
    }
    //调用static main时需要调用该类，所以执行一次静态代码块
    public static void main(String[] args) {
        User alen = new User("Alen", 23);
        User user = new User();
        user.showName();
        System.out.println(alen.name+" "+alen.age);
        System.out.println(User.min(User.l,user.id));
    }
}

---

其他

单例模式

进程中该类只能有一个实例，并且必须由自己创建并提供给其他对象

• 懒汉式（构建类时创建自己的实例对象，可能额外占用资源，但线程安全）
• 饿汉式（需要时动态创建实例对象，可能线程不安全）

工厂模式的实例化
创建型模式的一种，在工厂模式中，实例化时直接返回新实例

package myTest;

public class TaskManager {
    //单例模式，私有构造方法
    private TaskManager(int waiting, boolean running) {
        this.waiting = waiting;
        this.running = running;
    }
    private int waiting;
    private boolean running=false;
    //饿汉式，提前创建静态对象，不使用时也消耗额外空间，但是线程安全
    private static TaskManager task=new TaskManager(0,true);
    public static TaskManager getTask(){
        return task;
    }
    //懒汉式，需要时动态创建对象，不使用时不实例化，但是线程不安全
    public static TaskManager getTaskA(){
        if(task==null) return task=new TaskManager(0,true);
        return task;
    }
    //工厂模式返回实例，返回多个新实例
    public static TaskManager generateTask(){
        return new TaskManager(0,true);
    }
}