Hi, Sirius


Fortune favors the prepared mind

JavaSE

  • ~16.05K 字
  • 次阅读
  • 条评论
  1. 1. 面向对象(Object-Oriented Programming, OOP)
    1. 1.1. 方法的定义和调用
    2. 1.2. 构造器详解
    3. 1.3. 封装详解
    4. 1.4. 继承
      1. 1.4.1. 继承的特性
      2. 1.4.2. super与this关键字
      3. 1.4.3. final关键字
    5. 1.5. 重写(Override)与重载(Overload)
    6. 1.6. 多态
      1. 1.6.1. instanceof关键字
    7. 1.7. static关键字详解
      1. 1.7.1. static代码块
      2. 1.7.2. 静态导入包
    8. 1.8. 抽象类
    9. 1.9. 接口的定义与实现
    10. 1.10. 内部类
  2. 2. Java 核心概念综合示例
  3. 3. 参考

作为一款"工业级"编程语言，Java的重要性不言而喻

面向对象(Object-Oriented Programming, OOP)

面向对象编程的本质：以类的方式组织代码，以对象的组织（封装）数据

方法的定义和调用

方法的定义：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// Demo01 类
public class Demo01 {
    // main 方法
    public static void main(String[] args) {

    }
}
/*
    修饰符  返回值类型  方法名(...) {
        // 方法体
        return 返回值
    }
*/
public int max(int a, int b) {
    return a > b ? a : b;
}

方法的调用：

调用其他类的方法，除非是static静态方法，不然必须实例化这个类(new)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class Demo02 {

  public static void main(String[] args) {
    // 通过类名直接调用静态方法
    int add = Demo02.add(1, 2);

    // 非静态方法需要先实例化这个类new
    // 对象类型 对象名 = 对象值;
    Student student = new Student();
    student.say();
  }

  public static int add(int a, int b) {
    return a + b;
  }
}
1
2
3
4
5
6
7
8
// 学生类
public class Student {

  // 非静态方法
  public void say() {
    System.out.println("xxxx");
  }
}

构造器详解

使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化，以及对类中构造器的调用

类中的构造器也被称为构造方法，创建对象时必须要调用。有以下特点：

  1. 必须和类的名字相同
  2. 没有返回类型，也不能写void

构造器的作用：

  1. 使用new关键字，本质是在调用构造器
  2. 用来初始化值

封装详解

程序设计要追求：高内聚，低耦合。高内聚：类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用

封装（数据的隐藏）：通常应禁止直接访问一个对象中的数据的实际表示，而应通过操作接口来访问，这称为信息隐藏

属性私有，get/set

1
2
3
4
5
6
7
8
9
public class Demo03 {

  public static void main(String[] args) {
    Student s1 = new Student();
    
    s1.setName("java");
    System.out.println(s1.getName());
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// 学生类
public class Student {

  // 属性私有
  private String name;
  private int id;
  private char sex;

  // 提供一些可以操作这个属性的方法
  // 提供一些public的get，set方法

  public String getName() {
    return this.name;
  }

  public void setName(String name) {
    this.name = name;
  }
}

有时set中会做一些不合法数据的处理。由此看出，封装可以

  1. 提高程序的安全性，保护数据
  2. 隐藏代码的实现细节
  3. 统一接口
  4. 系统可维护增加

继承

Java中类只有单继承，没有多继承！

1
2
3
4
5
6
7
8
9
10
11
public class Animal {

    private String name;   
    private int id; 

    public Animal(String myName, String myid) { 
        //初始化属性值
    } 
    public void eat() {  //吃东西方法的具体实现  } 
    public void sleep() { //睡觉方法的具体实现  } 
} 
1
2
3
public class Penguin extends Animal { 

}

继承的特性

  1. 子类拥有父类非private的属性，方法
  2. 子类可以用有自己的属性和方法，即子类可以对父类进行扩展
  3. 子类可以用自己的方式实现父类的方法
  4. 提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系越紧密，代码独立性越差）

super与this关键字

  • super：可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类
  • this：指向自己的引用
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
class Animal {
  void eat() {
    System.out.println("animal : eat");
  }
}
 
class Dog extends Animal {
  void eat() {
    System.out.println("dog : eat");
  }

  void eatTest() {
    this.eat();   // this 调用自己的方法
    super.eat();  // super 调用父类方法
  }
}
 
public class Test {
  public static void main(String[] args) {
    Animal a = new Animal();
    a.eat();  // 输出：animal : eat

    Dog d = new Dog();
    d.eatTest();  // 输出：dog : eat
                  // 输出：animal : eat
  }
}

super注意点：

  1. super调用父类的构造方法，必须在构造方法的第一个
  2. super必须只能出现在子类的方法或者构造方法中
  3. super和this不能同时调用构造方法

对比this：

  • 代表的对象不同
    • this：本身调用者这个对象
    • super：代表父类对象的应用
  • 前提
    • this：没有继承也可以使用
    • super：只能在继承条件才可以使用
  • 构造方法
    • this()：本类的构造
    • super()：父类的构造

final关键字

final 关键字声明类可以把类定义为不能继承的，即最终类；或者用于修饰方法，该方法不能被子类重写：

声明类：

1
final class 类名 {//类体}

声明方法：

1
修饰符(public/private/default/protected) final 返回值类型 方法名(){//方法体}

重写(Override)与重载(Overload)

重写(Override)

@Override 重写，是指两个方法具有相同的方法名称和参数（即方法签名），分别位于父类和子类中，重写允许子类提供已经提供其父类的方法的特定实现

重载(Overload)

@Overload 重载：是指一个类中允许存在多个同名方法，而这些方法的参数表不同（参数个数或者参数类型不同）

@Override 重写：需要有继承关系，子类重写父类方法

  1. 方法名必须相同
  2. 参数列表必须相同
  3. 修饰符：范围可以扩大但不能缩小（public > protected > default > private）
  4. 抛出的异常：范围，可以被缩小，但不能扩大：ClassNotFoundException -> Exception（大）

多态

多态，即同一个方法可以根据发送对象的不同而采用多种不同的行为方式

还是以Student类继承Person类为例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class Demo04 {

  public static void main(String[] args) {

    // 一个对象的实际类型是确定的
    // new Student();
    // new Person();

    // 可以指向的引用类型就不确定了：父类的引用指向子类
    // Student能调用的方法都是自己的或者继承父类的！
    Student s1 = new Student();
    // Person父类型，可以指向子类，但是不能调用子类独有的方法
    Person s2 = new Student();
    
    // 对象能执行哪些方法，主要看对象左边的类型，与右边关系不大
    s2.run(); // 子类重写了父类的方法，执行子类的方法
    s1.eat(); // 子类自己调用自己的方法
    ((Student) s2).eat(); // 父类没有eat方法，要想调用必须强制类型转换为Student！
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
// Student类
public class Student extends Person {

  @Override
  public void run() {
    System.out.println("son");
  }

  // 子类独有方法
  public void eat() {
    System.out.println("eat");
  }
}
1
2
3
4
5
6
7
// Person类
public class Person {

  public void run() {
    System.out.println("run");
  }
}
  1. 父类引用指向子类的对象：Person s2 = new Student();
  2. 把子类转换为父类，向上转型
  3. 把父类转换为子类，向下转型：强制转换

多态存在的三个必要条件：

  1. 继承
  2. @Override 重写
  3. 父类引用指向子类对象：Parent p = new Child();

这里需要注意：有些方法不能被 @Override 重写：

  1. static方法，属于类，它不属于实例
  2. final方法：final是常量的
  3. private方法

instanceof关键字

instanceof运算符的前一个操作符是一个引用变量，后一个操作数通常是一个类（可以是接口），用于判断前面的对象是否是后面的类，或者其子类、实现类的实例。如果是返回true，否则返回false。也就是说：使用instanceof关键字做判断时， instanceof 操作符的左右操作数必须有继承或实现关系

static关键字详解

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class Student {

  private static int age; // 静态变量
  private double score; // 非静态变量

  public static void main(String[] args) {

    Student s1 = new Student();

    System.out.println(Student.age);
    System.out.println(Student.score);  // 报错！
    System.out.println(s1.age);
    System.out.println(s1.score);

  }
}

静态变量对于类，所有对象（实例）所共享，当直接使用类去调用得到说明这个变量是静态的

static代码块

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public class Person {
  
  // 2：赋初始值
  {
    System.out.println("匿名代码块");
  }
  // 1：只执行1次
  static {
    System.out.println("静态代码块");
  }

  // 3
  public Person() {
    System.out.println("构造方法");
  }

  public static void main(String[] args) {

    Person person1 = new Person();
    System.out.println("===============");
    Person person2 = new Person();
  }
}
1
2
3
4
5
6
静态代码块
匿名代码块
构造方法
===============
匿名代码块
构造方法

静态导入包

1
2
import static java.lang.Math.random;
import static java.lang.PI;

静态导入后，可以直接random()调用

抽象类

1
2
3
4
5
6
7
8
9
10
11
12
// abstract，抽象类
public abstract class Action {

  // 约束
  // abstract，抽象方法，只有方法名字，没有方法的实现
  public abstract void doSomething();

  // 1. 不能new这个抽象类，只能靠子类去实现它：约束！
  // 2. 抽象类中可以写普通方法
  // 3. 抽象方法必须在抽象类中

}
1
2
3
4
5
6
7
// 继承抽象类，抽象类的所有方法，继承了它的子类，都必须要实现它的方法，除非子类也是抽象类
public class A extends Action {
  @Override
  public void doSomething() {

  }
}

子类继承抽象类，那么就必须要实现抽象类没有实现的抽象方法，否则该子类也要声明为抽象类

接口的定义与实现

  • 普通类：只有具体实现
  • 抽象类：具体实现和规范（抽象方法）都有
  • 接口：只有规范，自己无法写方法

接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类

1
2
3
4
5
6
7
8
9
10
11
12
// 接口都需要有实现类
public interface UserService {

  // 常量 public static final，但一般没有在接口定义常量的
  int AGE = 99;

  // 接口中的所有定义都是抽象的 public abstract
  void add(String name);
  void delete(String name);
  void update(String name);
  void query(String name);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// 类，可以实现接口
// 实现了接口的类，就需要重写接口中的方法
public class UserServiceImpl implements UserService {

  @Override
  public void add(String name) {

  }

  @Override
  public void delete(String name) {

  }

  @Override
  public void update(String name) {

  }

  @Override
  public void query(String name) {

  }
}

虽然java只能单继承，但是可以通过接口实现多继承

1
2
3
4
5
6
7
8
9
10
11
12
public interface UserService {

  void add(String name);
  void delete(String name);
  void update(String name);
  void query(String name);
}

public interface TimeService {

  void timer();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
// 利用接口实现多继承
public class UserServiceImpl implements UserService, TimeService {

  @Override
  public void add(String name) {

  }

  @Override
  public void delete(String name) {

  }

  @Override
  public void update(String name) {

  }

  @Override
  public void query(String name) {

  }

  @Override
  public void timer() {

  }

}
抽象类和接口的区别

抽象类和接口的区别：

  1. 抽象类中的方法可以有方法体，就是能实现方法的具体功能，但是接口中的方法不行
  2. 抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 public static final 类型的
  3. 接口中不能含有静态代码块以及静态方法(用 static 修饰的方法)，而抽象类是可以有静态代码块和静态方法
  4. 一个类只能继承一个抽象类，而一个类却可以实现多个接口

内部类

内部类就是在一个类的内部定义一个类，比如，A类中定义一个B类，那么B类相对于A类来说就称为内部类，而A类相当B类来说就是外部类

  1. 成员内部类
  2. 静态内部类
  3. 局部内部类
  4. 匿名内部类

Java 核心概念综合示例

下面是一个包含 Java 所有核心概念的完整示例代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
// ============ 接口定义 ============
// 可移动接口
interface Movable {
    // 接口常量 (public static final)
    double MAX_SPEED = 300.0;

    // 抽象方法
    void move();
    double getSpeed();
}

// 可发声接口
interface Soundable {
    void makeSound();
}

// 接口继承：交通工具接口继承了 Movable 接口
interface Vehicle extends Movable {
    void start();
    void stop();
}

// ============ 抽象类 ============
abstract class Animal implements Soundable {
    // 私有属性（封装）
    private String name;
    private int age;

    // 静态变量（所有实例共享）
    private static int animalCount = 0;

    // 静态代码块（类加载时执行一次）
    static {
        System.out.println("Animal类被加载");
    }

    // 构造方法
    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
        animalCount++;
    }

    // getter/setter（封装）
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    // final 方法（不能被重写）
    public final void breathe() {
        System.out.println(name + " 正在呼吸");
    }

    // 静态方法
    public static int getAnimalCount() {
        return animalCount;
    }

    // 抽象方法（子类必须实现）
    public abstract void eat();

    // 普通方法
    public void sleep() {
        System.out.println(name + " 正在睡觉");
    }
}

// ============ 具体类（继承 + 实现多个接口）============
class Dog extends Animal implements Vehicle {
    // 子类特有属性
    private String breed;
    private double speed;

    // 构造方法
    public Dog(String name, int age, String breed) {
        // super 调用父类构造方法（必须在第一行）
        super(name, age);
        this.breed = breed;
        this.speed = 0.0;
    }

    // 重写父类抽象方法
    @Override
    public void eat() {
        System.out.println(getName() + " 正在吃骨头");
    }

    // 重写父类普通方法
    @Override
    public void sleep() {
        // super 调用父类方法
        super.sleep();
        System.out.println(getName() + " 睡得很香");
    }

    // 实现 Soundable 接口
    @Override
    public void makeSound() {
        System.out.println(getName() + " 汪汪叫");
    }

    // 实现 Vehicle 接口（来自 Movable）
    @Override
    public void move() {
        System.out.println(getName() + " 正在奔跑，速度: " + speed + "km/h");
    }

    @Override
    public double getSpeed() {
        return speed;
    }

    @Override
    public void start() {
        speed = 30.0;
        System.out.println(getName() + " 开始奔跑");
    }

    @Override
    public void stop() {
        speed = 0.0;
        System.out.println(getName() + " 停止奔跑");
    }

    // 方法重载（Overload）
    public void bark() {
        System.out.println(getName() + " 汪汪!");
    }

    public void bark(int times) {
        for (int i = 0; i < times; i++) {
            System.out.println(getName() + " 汪!");
        }
    }

    public void bark(String message) {
        System.out.println(getName() + " 说: " + message);
    }

    // 成员内部类
    public class Tail {
        private boolean wagging;

        public void wag() {
            wagging = true;
            // 内部类可以访问外部类的成员
            System.out.println(getName() + " 的尾巴在摇摆");
        }
    }

    // 静态内部类
    public static class DogHouse {
        private String location;

        public DogHouse(String location) {
            this.location = location;
        }

        public void showInfo() {
            System.out.println("狗窝位置: " + location);
        }
    }
}

// final 类（不能被继承）
final class Cat extends Animal {

    public Cat(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println(getName() + " 正在吃鱼");
    }

    @Override
    public void makeSound() {
        System.out.println(getName() + " 喵喵叫");
    }
}

// ============ 测试类 ============
public class JavaConceptDemo {

    public static void main(String[] args) {
        System.out.println("=== Java 核心概念综合演示 ===\n");

        // 1. 对象创建和封装
        System.out.println("1. 封装 - 创建对象:");
        Dog dog = new Dog("旺财", 3, "金毛");
        Cat cat = new Cat("小咪", 2);

        // 2. 继承
        System.out.println("\n2. 继承 - 调用父类方法:");
        dog.breathe();  // 调用父类 final 方法
        dog.sleep();    // 调用重写的方法

        // 3. 多态
        System.out.println("\n3. 多态 - 父类引用指向子类对象:");
        Animal animal = new Dog("大黄", 5, "哈士奇");
        animal.eat();        // 实际调用 Dog 的 eat 方法
        animal.makeSound();  // 实际调用 Dog 的 makeSound 方法

        // instanceof 判断
        if (animal instanceof Dog) {
            System.out.println("animal 是 Dog 的实例");
            // 向下转型
            Dog d = (Dog) animal;
            d.bark();  // 调用子类特有方法
        }

        // 4. 接口实现
        System.out.println("\n4. 接口实现 - 多接口:");
        Vehicle vehicle = dog;  // 向上转型为接口类型
        vehicle.start();
        vehicle.move();
        vehicle.stop();
        System.out.println("最高速度限制: " + Movable.MAX_SPEED);

        // 5. 方法重载
        System.out.println("\n5. 方法重载 (Overload):");
        dog.bark();
        dog.bark(3);
        dog.bark("你好!");

        // 6. 静态成员
        System.out.println("\n6. 静态成员:");
        System.out.println("动物总数: " + Animal.getAnimalCount());

        // 7. 内部类
        System.out.println("\n7. 内部类:");
        // 成员内部类
        Dog.Tail tail = dog.new Tail();
        tail.wag();
        // 静态内部类
        Dog.DogHouse house = new Dog.DogHouse("后院");
        house.showInfo();

        // 8. 匿名内部类
        System.out.println("\n8. 匿名内部类:");
        Animal bird = new Animal("小鸟", 1) {
            @Override
            public void eat() {
                System.out.println(getName() + " 正在吃虫子");
            }

            @Override
            public void makeSound() {
                System.out.println(getName() + " 叽叽喳喳");
            }
        };
        bird.eat();
        bird.makeSound();

        // 9. final 关键字
        System.out.println("\n9. final 关键字:");
        final int MAX_AGE = 100;  // final 变量（常量）
        System.out.println("最大年龄限制: " + MAX_AGE);
        cat.breathe();  // 调用 final 方法
        // Cat 类是 final 的，不能被继承

        System.out.println("\n=== 演示完成 ===");
    }
}

这个示例代码包含了以下所有 Java 核心概念：

  1. 封装：private 属性 + getter/setter
  2. 继承：Dog/Cat extends Animal
  3. 多态：父类引用指向子类对象、方法重写
  4. 接口：Movable、Soundable、Vehicle 接口定义和实现
  5. 接口继承：Vehicle extends Movable
  6. 抽象类：Animal 抽象类
  7. 重写(Override)：子类重写父类方法
  8. 重载(Overload)：bark() 方法的多个版本
  9. static 关键字：静态变量、静态方法、静态代码块
  10. final 关键字：final 类、final 方法、final 变量
  11. super 关键字：调用父类构造方法和方法
  12. this 关键字：引用当前对象
  13. instanceof 关键字：类型判断
  14. 向上转型：子类转父类/接口
  15. 向下转型：父类转子类（强制转换）
  16. 内部类：成员内部类、静态内部类、匿名内部类
  17. 构造方法：有参构造、构造方法调用顺序

参考

本作品采用 知识共享署名-相同方式共享 4.0 国际许可协议 进行许可