Java高效开发

原创 已于 2025-08-30 11:16:06 修改 · 699 阅读 · 28 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#intellij-idea #java #ide

于 2025-08-29 17:58:55 首次发布

Idea快捷键

  • psvm 快速生成main函数，（测试类）
  • alt+insert 快速生成（javabeen类 ）
  • javabeen需要有private修饰成员变量方法，一个空参构造，一个带参构造。成员方法的set和get方法。
  • sout 快速生成输出语句。
  • 用private修饰构造方法，就是生成一个（工具类），工具类里面可以写方法。
  • 用static修饰的变量为 静态变量 （全局可以用）
  • 用static修饰的方法为静态方法。（静态方法中没有this关键字）
  • 静态方法可以不用实例化就可以直接用
  • 选中几行代码按住ctrl+alt+m，快速将选中的代码封装为一个方法、

static 静态

        静态成员是 属于类本身的，而不是对象。

静态变量

  • 普通变量：属于对象，每个对象一份。

  • 静态变量：属于类，所有对象共享一份。

  • class User {
    public static int count = 0;  // 静态变量，统计用户数量
    public String name;           // 普通变量，每个对象独立

    public User(String name) {
        this.name = name;
        count++;  // 每次创建对象，count 递增
    }
}

public class Test {
    public static void main(String[] args) {
        User u1 = new User("Tom");
        User u2 = new User("Jerry");
        System.out.println(User.count); // 输出 2
    }
}

静态方法

  • 直接通过类调用，不需要对象。

  • 限制：静态方法中不能访问非静态变量和非静态方法。

  • class MathUtil {
    public static int add(int a, int b) { //注意static关键字
        return a + b;
    }
}

public class Test {
    public static void main(String[] args) {
        System.out.println(MathUtil.add(3, 5)); // 8  直接调用
    }
}

    要调用实例方法，必须先创建对象。

  • class MathUtil {
    public int add(int a, int b) {  //无static关键字
        return a + b;
    }
}

public class Test {
    public static void main(String[] args) {
        MathUtil util = new MathUtil(); // 先创建对象，在调用方法
        System.out.println(util.add(3, 5)); // ✅ 输出 8
    }
}

    final

    修饰类

  • final class：不能被继承。意思为最后的

  • final class Animal {}
// class Dog extends Animal {} // ❌ 报错

    修饰方法

  • final 方法不能被子类重写。

  • class Animal {
    public final void run() {
        System.out.println("Animal is running");
    }
}
class Dog extends Animal {
    // public void run() {} // ❌ 报错
}

    修饰变量

  • 变量变成常量，赋值后不可再改。

  • final int a = 10;
// a = 20; // ❌ 报错

    接口 interface

    接口是一组规范/约定，定义了方法签名，但不提供实现（Java8 开始可以有 default 方法）。

  • interface USB {
    void connect();
    void disconnect();
}

class Mouse implements USB {
    @Override
    public void connect() {
        System.out.println("Mouse connected");
    }
    @Override
    public void disconnect() {
        System.out.println("Mouse disconnected");
    }
}

public class Test {
    public static void main(String[] args) {
        USB usb = new Mouse(); // 多态
        usb.connect();
    }
}

作用：
统一标准，方便解耦。
实现多继承（一个类可以实现多个接口）。

    抽象类 abstract

    介于普通类和接口之间。可以写方法的声明（抽象方法）和部分实现。

  • abstract class Animal {
    public abstract void sound(); // 抽象方法，没有实现
    public void eat() {           // 普通方法，有实现
        System.out.println("Animal eating");
    }
}

class Dog extends Animal {
    @Override
    public void sound() {
        System.out.println("Woof!");
    }
}

作用：
定义一个基础骨架，部分由子类完成。
当一类事物有 共同点（可以写在父类），又有 差异点（抽象方法由子类实现）。
    特性接口 interface抽象类 abstract class
    继承关系一个类可实现多个接口一个类只能继承一个抽象类
    方法默认都是抽象方法（Java8 有 default）可有抽象方法和普通方法
    属性public static final 常量可定义变量（可有不同修饰符）
    使用场景更强调行为约定（能做什么）更强调模板骨架（是什么）

  • 多态的三个条件

  • 要有继承或实现关系

  • 父类引用指向子类对象

  • 调用方法时表现为“编译看左边，运行看右边”

    • 编译时：检查父类是否有这个方法

    • 运行时：实际调用子类的实现（如果子类重写了方法）

  • class Person {
    public void say() {
        System.out.println("Person say");
    }
}

class User extends Person {
    @Override
    public void say() {
        System.out.println("User say");
    }
}

public class Test {
    public static void main(String[] args) {
        Person p = new User(); // 向上转型
        p.say();               // 输出: User say
    }
}

Person p = new User();
p.say(); 
这两行代码
编译的时候看左边（看父类Person是否有say方法）、运行看右边（看User类是否有say方法）。

多态的核心作用：解耦、扩展、复用。一句话总结：用父类/接口来定义规范，
用子类来实现细节，运行时根据实际对象决定执行哪个方法。

真实场景

Spring 框架：List list = new ArrayList(); 或 List list = new LinkedList();
→ 程序依赖 List 接口，不关心用哪种实现。

数据库开发：Connection conn = new MysqlConnection(); 或 Connection conn = new OracleConnection();
→ 程序写死 Connection，换数据库时不用改业务代码。

策略模式、工厂模式 都是基于多态。

  • 访问控制修饰符（权限范围）

    作用：控制谁能访问。
    适用：类、方法、变量、构造方法。

  • 修饰符同类中同包子类其他包
    public✅✅✅✅
    protected✅✅✅❌
    default(不写)✅✅❌❌
    private✅❌❌❌
class User {
    public String name;       // 任何地方都能访问
    protected int age;        // 子类可以访问
    String address;           // 包内访问
    private String password;  // 仅类内访问
}

private 只能在当前类内用。私有 
default(不写) 只能在当前包内的类文件使用
protected 只有继承的可以用.
public 不限制，都可以用

类相关修饰符

static 静态

  • 修饰变量：属于类，所有对象共享。

  • 修饰方法：类方法，类名直接调用。

final 常量/禁止继承或重写

  • 修饰类：类不能被继承。

  • 修饰方法：方法不能被重写。

  • 修饰变量：值不能被修改。

abstract 抽象

  • 修饰类：类不能实例化，必须被继承。

  • 修饰方法：方法没有实现，必须由子类实现。

synchronized

  • 用于多线程，保证方法或代码块同一时间只被一个线程访问。

native

  • 声明本地方法（用 C/C++ 实现）。

继承和多态相关修饰符

override（不是关键字，而是注解 @Override）

  • 表示子类重写父类方法。

transient

  • 修饰变量，表示该变量不参与序列化。

volatile

  • 修饰变量，保证多线程下变量的可见性。

常见组合举例

public class Example {
    public static final double PI = 3.14; // 公共常量
    private int id;                       // 私有成员
    protected String name;                // 子类可见
    transient String cache;               // 不序列化

    public final void run() {}            // 不能被重写
    public static void print() {}         // 静态方法
    public abstract void work();          // 抽象方法
}

总结：

权限控制：public、protected、default、private

类行为：static、final、abstract、synchronized、native

变量特性：transient、volatile

浮点标准：strictfp

修饰符类方法变量含义
访问控制
public✅✅✅任何地方可见
protected❌✅✅同包和子类可见
default(不写)✅✅✅仅同包可见
private❌✅✅仅类内部可见
类相关
static❌✅✅属于类，不依赖对象
final✅✅✅类不能继承；方法不能重写；变量不能修改
abstract✅✅❌类不能实例化；方法必须由子类实现
并发控制
synchronized❌✅❌方法/代码块同一时刻仅一个线程访问
volatile❌❌✅多线程下保证变量的可见性
序列化
transient❌❌✅变量不参与序列化
其他
native❌✅❌方法用 C/C++ 实现
strictfp✅✅❌保证浮点计算符合 IEEE754

修饰符组合适用示例典型用途
public static final变量public static final double PI = 3.14;常量定义，所有类可访问，不可修改
private static变量/方法private static int count;类级别的私有数据或工具方法（单例模式常用）
protected abstract方法protected abstract void work();父类定义模板，子类必须实现
public abstract类/方法public abstract class Shape {}抽象类或方法，约束子类
public final类/方法/变量public final class String {}类不能继承；方法不能重写；变量变常量
private final变量private final int id;私有常量，构造方法里赋值一次
synchronized + 访问修饰符方法public synchronized void add() {}保证多线程安全
volatile变量private volatile boolean flag;多线程共享变量，避免缓存不一致
transient变量private transient String cache;序列化时跳过该字段
// 工具类：方法全是静态
public class MathUtil {
    public static int add(int a, int b) {
        return a + b;
    }
}

// 常量池：公共常量
public class Config {
    public static final String APP_NAME = "StudentSystem";
}

// 单例模式：私有静态变量
public class Singleton {
    private static final Singleton instance = new Singleton();
    private Singleton() {}
    public static Singleton getInstance() {
        return instance;
    }
}

// 抽象类 + 抽象方法
public abstract class Animal {
    public abstract void sound(); // 子类必须实现
}

// 线程安全的方法
public class Counter {
    private int count = 0;
    public synchronized void increment() {
        count++;
    }
}

面向对象的难点

1. 继承 (extends) 的细节

  • 单继承：Java 一个类只能继承一个父类，但可以实现多个接口。

  • 构造方法不继承，但子类会默认先调用父类的无参构造。

  • 方法重写要符合规则（参数列表相同，返回值相同或更窄，访问权限不能变小）。

  • class Person {
    String name;
    public void work() { System.out.println("工作"); }
}

class Teacher extends Person {
    @Override
    public void work() { System.out.println("教书"); }
}

**难点：**父类引用可以指向子类对象（多态），但只能访问父类定义的内容。

2. 多态的真实价值

  • 向上转型：Person p = new Teacher();

  • 运行时决定方法执行版本（动态绑定）。

  • 好处：解耦，扩展性强，符合开闭原则。

例子：

void doWork(Person p) {
    p.work(); // 传 Teacher 就是教书，传 Student 就是学习
}

3. 抽象类 vs 接口

  • 抽象类：abstract class，可以有成员变量、构造方法、非抽象方法，适合“is-a”关系。

  • 接口：interface，只能定义常量和抽象方法（Java 8+ 可有默认方法、静态方法），更强调“can-do”能力。

例子：

abstract class Animal { abstract void sound(); }

interface Flyable { void fly(); }

class Bird extends Animal implements Flyable {
    void sound() { System.out.println("叽叽喳喳"); }
    public void fly() { System.out.println("鸟会飞"); }
}

4. static 与 对象成员的区别

  • static 属于类，所有对象共享，不依赖实例。

  • 非 static 属于对象，每个实例独立。

例子：

class Counter {
    static int total = 0;  // 所有对象共享
    int id;                // 每个对象独立
    public Counter(int id) {
        this.id = id;
        total++;
    }
}

5. final 的三种用法

  • final class：类不能被继承（如 String）。

  • final method：方法不能被重写。

  • final variable：变量是常量，必须初始化一次，不能再改。

6. 对象比较

  • == 比较内存地址。

  • equals() 默认也是比较地址，但很多类（如 String）重写了，变成内容比较。

评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值