Profile Image of the Author
糖糖IT
公告
为世界添砖加瓦！
标签
1224 字
3 分钟
Java基础核心知识：OOP原则、访问修饰符、泛型与内部类
2026-01-06
Java核心
Java
/
OOP
/
泛型
/
内部类
/
访问修饰符

面向对象编程的六大原则?#

记忆：单开里迪，依赖接口

  • 单一职责：对象设计要求独立，不能设计万能对象。
  • 开闭原则：对象修改最小化。
  • 里式替换：程序扩展中抽象被具体可以替换（接口、父类、可以被实现类对象、子类替换对象）
  • 迪米特：高内聚，低耦合。尽量不要依赖细节。
  • 依赖倒置：面向抽象编程。也就是参数传递，或者返回值，可以使用父类类型或者接口类型。从广义上讲：基于接口编程，提前设计好接口框架。
  • 接口隔离：接口设计大小要适中。过大导致污染，过小，导致调用麻烦。

数组到底是不是对象？#

著作权归大彬所有 原文链接：https://www.topjavaer.cn/java/java-basic.html

访问修饰符#

Java访问控制修饰符总结#

修饰符可见性说明
public所有类可见具有最高级别的访问权限。
protected同一包内和继承类（不同包）可见提供比默认访问级别更高的权限，通常与继承结合使用。
默认（无修饰符）同一包内可见，其他包内不可见如果没有使用任何修饰符，默认为包级别的访问权限。
private仅在声明它的类内部可见提供最高级别的封装，对于外部类完全不可见。

Java中有四种主要的访问控制修饰符，用于控制类的成员（字段、方法等）的访问权限。这些修饰符按照访问权限逐渐降低的顺序排列：

1. public#

  • 可以被任何类访问，无论是否在同一包内。
  • 具有最高的访问级别。

2. protected#

  • 可以被同一包内的类和继承类访问。
  • 具有比默认访问级别更高的访问权限，但比public低。

3. 默认（包级别）#

  • 如果没有使用任何修饰符，默认是包级别的访问权限。
  • 可以被同一包内的类访问，但对于不在同一包内的类是不可见的。

4. private#

  • 只能被声明它的类内部访问。
  • 提供最高级别的封装，对于外部类完全不可见。

访问修饰符作用域

重要注意事项：#

  • 封装：使用private和protected有助于实现封装，隐藏内部实现细节。

  • 继承：protected通常与继承结合使用，允许子类访问父类的protected成员。

  • 面向对象原则：访问控制修饰符有助于实现面向对象编程的封装、继承和多态原则。

  • 安全性：选择适当的访问级别有助于确保代码的安全性和可维护性。

总体而言，Java的访问控制修饰符为程序员提供了灵活性，使其能够根据设计需求控制类成员的访问权限，从而更好地组织和保护代码。

泛型使用#

Java 中泛型的使用涉及到类、接口、方法等不同的场景。以下是一些泛型的常见使用场景和示例：

1. 泛型类#

// 泛型类
class Box<T> {
    private T value;


    // 构造方法
    public Box(T value) {
        this.value = value;
    }


    // 获取值的方法
    public T getValue() {
        return value;
    }
}


// 使用泛型类
Box<Integer> integerBox = new Box<>(123);
Box<String> stringBox = new Box<>("Hello");


// 获取值
int intValue = integerBox.getValue();
String stringValue = stringBox.getValue();

2. 泛型接口#

// 泛型接口
interface Pair<K, V> {
    K getKey();
    V getValue();
}


// 实现泛型接口
class OrderedPair<K, V> implements Pair<K, V> {
    private K key;
    private V value;


    public OrderedPair(K key, V value) {
        this.key = key;
        this.value = value;
    }


    @Override
    public K getKey() {
        return key;
    }


    @Override
    public V getValue() {
        return value;
    }
}


// 使用泛型接口
Pair<String, Integer> pair = new OrderedPair<>("One", 1);
System.out.println(pair.getKey() + ": " + pair.getValue());

3. 泛型方法#

// 泛型方法
class Utils {
    //在方法定义中，使用了尖括号 <T> 来声明泛型类型 T，这表示这是一个泛型方法。 返回值是T
    public static <T> T getLastElement(T[] array) {
        return array[array.length - 1];
    }
}


// 使用泛型方法
Integer[] intArray = {1, 2, 3, 4, 5};
String[] stringArray = {"A", "B", "C"};


Integer lastInt = Utils.getLastElement(intArray);
String lastString = Utils.getLastElement(stringArray);


System.out.println("Last Integer: " + lastInt);
System.out.println("Last String: " + lastString);

4. 通配符#

// 使用通配符
class Printer {
    public static void printList(List<?> list) {
        for (Object item : list) {
            System.out.print(item + " ");
        }
        System.out.println();
    }
}


// 使用通配符
List<Integer> intList = Arrays.asList(1, 2, 3, 4, 5);
List<String> stringList = Arrays.asList("A", "B", "C");


Printer.printList(intList);
Printer.printList(stringList);

这些例子展示了 Java 中泛型的一些常见用法，包括泛型类、泛型接口、泛型方法以及通配符的使用。泛型使得代码更加灵活、类型安全，并提高了代码的重用性。

内部类#

在 Java 中，内部类是在一个类的内部定义的类。有四种主要类型的内部类：成员内部类、局部内部类、匿名内部类和静态内部类。以下是它们的写法：

1. 成员内部类#

成员内部类是定义在另一个类的内部的类。它可以访问外部类的成员，包括私有成员。

public class OuterClass {
    private int outerVar;


    public class InnerClass {
        private int innerVar;


        public void innerMethod() {
            // 可以访问外部类的成员
            outerVar = 10;
            System.out.println("Inner Method");
        }
    }
}

2. 局部内部类#

局部内部类是定义在方法或作用域内的类，只在定义它的方法或作用域内可见。

public class OuterClass {
    public void outerMethod() {
        // 局部内部类
        class LocalInnerClass {
            public void localMethod() {
                System.out.println("Local Method");
            }
        }


        LocalInnerClass localInner = new LocalInnerClass();
        localInner.localMethod();
    }
}

3. 匿名内部类#

匿名内部类是没有类名的内部类，通常用于创建接口的实例。

public interface MyInterface {
    void myMethod();
}


public class OuterClass {
    public void useInner() {
        // 匿名内部类
        MyInterface myInterface = new MyInterface() {
            @Override
            public void myMethod() {
                System.out.println("Anonymous Inner Method");
            }
        };


        myInterface.myMethod();
    }
}

4. 静态内部类#

静态内部类是使用 static 修饰的内部类，不依赖于外部类的实例。可以直接通过外部类名访问。

public class OuterClass {
    private static int staticVar;


    public static class StaticInnerClass {
        private int innerVar;


        public void innerMethod() {
            // 可以访问外部类的静态成员
            staticVar = 20;
            System.out.println("Static Inner Method");
        }
    }
}

这是 Java 中内部类的常见写法。每种内部类都有其自身的使用场景和特点，选择合适的内部类类型取决于具体的需求。

分享

如果这篇文章对你有帮助，欢迎分享给更多人！

Java基础核心知识：OOP原则、访问修饰符、泛型与内部类
https://onecodemaker.cn/posts/java核心-01-基础/
作者
糖糖IT
发布于
2026-01-06
许可协议
CC BY-NC-SA 4.0

部分信息可能已经过时

Java集合核心问题：哈希冲突与并发修改异常
相关文章 智能推荐
1
Java多线程与并发编程深度解析
Java核心 全面覆盖Java多线程核心知识：线程基础、CompletableFuture异步编程、锁机制、CAS与原子类、ThreadLocal、JMM、volatile、对象内存布局与锁升级。
2
Java反射机制详解：Class、Field、Method与Constructor
Java核心 系统讲解Java反射机制的核心类（Class/Field/Method/Constructor）的常用方法，通过Book示例演示反射创建对象、访问私有成员，并分享通联支付项目中的反射架构实践。
3
Java集合核心问题：哈希冲突与并发修改异常
Java核心 解析HashMap哈希冲突的解决机制、equals与hashCode的契约关系，以及ConcurrentModificationException的成因与迭代器安全删除方案。
4
JVM虚拟机核心知识体系
Java核心 从JVM组成结构（类加载子系统、运行时数据区、执行引擎）、对象创建与内存布局、字节码文件结构到JVM调优，构建完整的JVM知识图谱。
5
Spring AOP原理与自定义注解详解
Java核心 从静态代理、JDK动态代理到CGLIB代理，深入理解Spring AOP的实现原理与通知执行顺序；结合面试题分析Spring4/Boot2的AOP差异；系统讲解Java注解机制与自定义注解实践。
蜀ICP备2025151085号
© 2026 糖糖IT. All Rights Reserved. / RSS / Atom / Sitemap
Powered by Astro & Mizuki  Version 9.0

目录