目录
Java高级面向对象编程
在这篇博客文章中,我们将探索Java中的高级面向对象编程概念,包括接口、内部类和常用API。每个概念都将通过代码示例来演示它们的应用。
Java中的接口
什么是接口?
接口是Java中的一种引用类型,类似于类,它可以包含常量、方法签名、默认方法、静态方法和嵌套类型。接口不能包含实例字段,接口中的方法默认是抽象的。
接口的特点
- **声明**:接口使用`interface`关键字声明。
- **实现**:类使用`implements`关键字实现接口。
- **多继承**:一个类可以实现多个接口。
示例
```java
public interface Animal {
void eat();
void sleep();
}
public class Dog implements Animal {
@Override
public void eat() {
System.out.println("Dog eats bone");
}
@Override
public void sleep() {
System.out.println("Dog sleeps");
}
public static void main(String[] args) {
Dog dog = new Dog();
dog.eat();
dog.sleep();
}
}
```
在这个示例中,我们定义了一个名为`Animal`的接口,和一个实现该接口的`Dog`类。`Dog`类实现了`Animal`接口的所有方法。
JDK 8及以后接口的新特性
- **默认方法**:使用`default`关键字,允许在接口中定义方法体。
- **静态方法**:使用`static`关键字,可以直接在接口中调用,而不需要实现类。
- **私有方法**:从JDK 9开始,接口可以包含`private`方法,供其他默认方法或私有方法调用。
示例
```java
public interface Vehicle {
default void start() {
System.out.println("Vehicle is starting");
}
static void check() {
System.out.println("Vehicle check");
}
private void clean() {
System.out.println("Vehicle clean");
}
}
public class Car implements Vehicle {
public static void main(String[] args) {
Car car = new Car();
car.start(); // 调用默认方法
Vehicle.check(); // 调用静态方法
}
}
```
Java中的内部类
内部类的概述
内部类是在一个类里面定义的类。根据定义的位置不同,内部类可以分为以下几种类型:
1. **静态内部类**:使用`static`关键字修饰,属于外部类本身。
2. **成员内部类**:不使用`static`修饰,属于外部类的对象。
3. **局部内部类**:定义在方法、代码块或构造器中。
4. **匿名内部类**:没有名字的内部类,通常用于简化代码。
示例:静态内部类
```java
public class Outer {
public static class StaticInner {
public void display() {
System.out.println("Static Inner Class");
}
}
public static void main(String[] args) {
Outer.StaticInner inner = new Outer.StaticInner();
inner.display();
}
}
```
示例:成员内部类
```java
public class Outer {
public class MemberInner {
public void show() {
System.out.println("Member Inner Class");
}
}
public static void main(String[] args) {
Outer outer = new Outer();
Outer.MemberInner inner = outer.new MemberInner();
inner.show();
}
}
```
示例:匿名内部类
```java
public interface Greeting {
void sayHello();
}
public class Main {
public static void main(String[] args) {
Greeting greeting = new Greeting() {
@Override
public void sayHello() {
System.out.println("Hello, Anonymous Inner Class!");
}
};
greeting.sayHello();
}
}
```
常用API
Object类
`Object`类是Java所有类的父类,提供了一些常用方法,如`toString()`和`equals()`。
示例
```java
public class Person {
private String name;
public Person(String name) {
this.name = name;
}
@Override
public String toString() {
return "Person{name='" + name + "'}";
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Person person = (Person) o;
return name.equals(person.name);
}
public static void main(String[] args) {
Person p1 = new Person("Alice");
Person p2 = new Person("Alice");
System.out.println(p1); // 输出:Person{name='Alice'}
System.out.println(p1.equals(p2)); // 输出:true
}
}
```
StringBuilder类
`StringBuilder`是一个可变的字符串类,提供了高效的字符串操作能力。
示例
```java
public class StringBuilderExample {
public static void main(String[] args) {
StringBuilder sb = new StringBuilder();
sb.append("Hello");
sb.append(" ");
sb.append("World");
System.out.println(sb.toString()); // 输出:Hello World
}
}
```
通过这些示例,我们可以看到Java中的高级面向对象编程概念如何应用于实际开发中,提高代码的灵活性和可维护性。
---
希望这篇文章对您理解Java的高级面向对象概念有所帮助!如果有任何问题,欢迎讨论。
标签:进阶,void,多态,接口,System,API,static,println,public From: https://blog.csdn.net/2302_80084329/article/details/140882135