目录
1.抽象类
1.1抽象类概念
抽象类是面向对象编程中的一个概念，它是一种不能被实例化的类。抽象类用来定义一些共享的特性和行为，并且可以提供一些具体的方法实现。抽象类通常用作其他类的父类或接口的实现类。
// 抽象类：被abstract修饰的类
public abstract class Shape {
// 抽象方法：被abstract修饰的方法，没有方法体
abstract public void draw();
abstract void calcArea();
// 抽象类也是类，也可以增加普通方法和属性
public double getArea(){
return area;
}
protected double area; // 面积
}1.2抽象类特点
抽象类具有以下特点：
抽象类不能被实例化：抽象类不能直接创建对象，只能通过它的子类来实例化。
抽象方法：抽象类中可以包含抽象方法，它们没有具体的实现，只有方法签名。子类必须实现抽象方法，否则子类也必须声明为抽象类。
具体方法：抽象类中可以包含具体的方法，这些方法有具体的实现。
字段和常量：抽象类可以包含字段和常量，这些字段和常量可以在子类中使用。
继承和多态：其他类可以继承抽象类，并继承其特性和行为。通过抽象类，可以实现多态，即通过父类类型引用子类对象。
// 矩形类 public class Rect extends Shape { private double length; private double width; Rect(double length, double width){ this.length = length; this.width = width; } public void draw(){ System.out.println("矩形: length= "+length+" width= " + width); } public void calcArea(){ area = length * width; } } // 圆类： public class Circle extends Shape{ private double r; final private static double PI = 3.14; public Circle(double r){ this.r = r; } public void draw(){ System.out.println("圆：r = "+r); } public void calcArea(){ area = PI * r * r; } } // 三角形类： public abstract class Triangle extends Shape { private double a; private double b; private double c; @Override public void draw() { System.out.println("三角形：a = "+a + " b = "+b+" c = "+c); } // 三角形：直角三角形、等腰三角形等，还可以继续细化 //@Override //double calcArea(); // 编译失败：要么实现该抽象方法，要么将三角形设计为抽象类 }
抽象类的主要目的是提供一种模板或约定，用于定义一组相关类的共同特征和行为。子类可以继承抽象类并提供特定的实现，从而实现代码的复用和扩展。
1.3抽象类的应用
抽象类常用于以下场景：
-
定义一组相关类的通用属性和方法。
-
定义接口，使多个类具备共同的特性。
-
限制子类的实现，确保子类实现了必要的方法。
总之，抽象类是一种在面向对象编程中用于定义共享特征和行为的概念，它提供了一种模板或约定，用于定义一组相关类的通用属性和方法。通过继承抽象类，子类可以继承其特性并提供特定的实现。
2.接口
2.1接口的概念
接口是面向对象编程中的一个概念，它用于定义一组方法的集合，但没有具体的实现。接口可以被类实现，实现类须提供接口中声明的所有方法的具体实现。（IDEA 中使用 ctrl + i 快速实现接口 ）
2.2接口的特点
接口具有以下特点：
- 接口当中的成员变量默认是public static final修饰的
public static final int a = 10; int b = 20;- 接口当中的抽象方法默认都是public abstract修饰的
public abstract void draw(); void draw1();接口是不可以进行实例化的
- 如果接口当中的方法被default / static修饰，那么也可以有具体的实现
default void test(){ System.out.println("default方法"); } static void test1(){ System.out.println("static方法"); }类和接口之间可用关键字implements来实现接口，必须实现接口中的抽象方法
public class Cycle implements IShape{ @Override public void draw() { } }public interface USB { // 编译失败 public USB(){ } {} // 编译失败 void openDevice(); void closeDevice(); }
- 接口虽然不是类，但是接口编译完成后字节码文件的后缀格式也是.class
- 如果类没有实现接口中的所有的抽象方法，则类必须设置为抽象类
2.3应用
请实现笔记本电脑使用USB鼠标、USB键盘的例子
1. USB接口：包含打开设备、关闭设备功能2. 笔记本类：包含开机功能、关机功能、使用USB设备功能3. 鼠标类：实现USB接口，并具备点击功能4. 键盘类：实现USB接口，并具备输入功能
//Test.java
package demo3;
public class Test {
public static void main(String[] args) {
Computer computer = new Computer();
computer.open();
System.out.println();
computer.useUSBDevice(new Mouse());
System.out.println();
computer.useUSBDevice(new Keyboard());
System.out.println();
computer.close();
}
}
//USB.java
package demo3;
public interface USB {
void openDevice();
void closeDevice();
}
//Mouse.java
package demo3;
public interface USB {
void openDevice();
void closeDevice();
}
//Keyboard.java
package demo3;
public class Keyboard implements USB{
@Override
public void openDevice() {
System.out.println("open the keyboard");
}
@Override
public void closeDevice() {
System.out.println("close the keyboard");
}
public void input(){
System.out.println("input something");
}
}
//Computer.java
package demo3;
public class Computer {
public void open(){
System.out.println("open the computer");
}
public void close(){
System.out.println("close the computer");
}
public void useUSBDevice(USB usb){
usb.openDevice();
if(usb instanceof Mouse){
Mouse mouse = (Mouse)usb;
mouse.click();
}else{
Keyboard keyboard = (Keyboard)usb;
keyboard.input();
}
usb.closeDevice();
}
}输出结果：
2.4实现多个接口
//Duck.java
public class Duck extends Animal implements ISwimming,IRunning,IFlying{
public Duck(int age, String name) {
super(age, name);
}
@Override
public void eat() {
System.out.println(this.name + " is eating duck food");
}
@Override
public void fly() {
System.out.println(this.name + " is flying");
}
@Override
public void run() {
System.out.println(this.name + " is running");
}
@Override
public void swim() {
System.out.println(this.name + " is swimming");
}
}
//ISwimming.java
public interface ISwimming {
void swim();
}
//IRunning.java
public interface IRunning {
void run();
}
//IFlying.java
public interface IFlying {
void fly();
}
2.5接口间的继承
在Java中，接口之间也可以进行继承，这种继承关系称为接口的继承（Interface Inheritance）。接口之间的继承使用关键字"extends"来表示。
接口的继承可以使得一个接口继承另一个接口的方法和常量，通过继承，子接口可以拥有父接口中定义的所有方法和常量，同时可以定义自己的方法和常量。
interface 子接口名 extends 父接口名 {
// 子接口定义的方法和常量
}
3.Object类
Object类是Java中所有类的根类，它是Java类继承层次结构中的最顶层的父类。在Java中，所有的类都直接或间接地继承自Object类。
Object类定义了一些在所有对象中通用的方法，因此所有的Java类都可以使用这些方法。以下是一些Object类的常用方法：
- equals(Object obj)：判断当前对象和指定对象是否相等。
- hashCode()：返回当前对象的哈希码。
- toString()：返回当前对象的字符串表示。
- getClass()：返回当前对象的运行时类。
- finalize()：在垃圾回收器回收对象之前调用。
- clone()：创建并返回当前对象的副本。
- wait()、notify()和notifyAll()：用于线程间的通信。
Object类还有一些其他的方法，但以上列举的是最常用的方法。其他的方法包括getClassLoader()、finalize()、notifyAll()等。
由于所有的类都继承自Object类，因此可以在任何类的实例上调用Object类的方法。例如，可以在任何类的对象上使用equals()方法来比较它们是否相等。
需要注意的是，Object类中的方法可以在子类中进行重写以提供更具体的实现。例如，可以重写toString()方法来返回特定对象的自定义字符串表示。
3.1toString()方法
用来获取对象信息。
public String toString() {
return getClass().getName() + "@" + Integer.toHexString(hashCode());
}3.2equals方法
在Java中，==进行比较时：
- 如果==左右两侧是基本类型变量，比较的是变量中值是否相同
- 如果==左右两侧是引用类型变量，比较的是引用变量地址是否相同
- 如果要比较对象中内容，必须重写Object中的equals方法，因为equals方法默认也是按照地址比较的：
// Object类中的equals方法 public boolean equals(Object obj) { return (this == obj); // 使用引用中的地址直接来进行比较 }class Person{ private String name ; private int age ; public Person(String name, int age) { this.age = age ; this.name = name ; } } public class Test { public static void main(String[] args) { Person p1 = new Person("gaobo", 20) ; Person p2 = new Person("gaobo", 20) ; int a = 10; int b = 10; System.out.println(a == b); // 输出true System.out.println(p1 == p2); // 输出false System.out.println(p1.equals(p2)); // 输出false } }
重写equals:
class Person{
...
@Override
public boolean equals(Object obj) {
if (obj == null) {
return false ;
}
if(this == obj) {
return true ;
}
// 不是Person类对象
if (!(obj instanceof Person)) {
return false ;
}
Person person = (Person) obj ; // 向下转型，比较属性值
return this.name.equals(person.name) && this.age==person.age ;
}
}结论：比较对象中内容是否相同的时候，一定要重写equals方法。
3.3hashcode方法
在Java中，哈希码是通过hashCode()方法生成的。Object类中的hashCode()方法的默认实现是根据对象的内存地址计算得出的，因此不同对象的哈希码一般是不相同的。但是，根据需要，可以在自定义类中重写hashCode()方法，以根据具体需求生成哈希码。
public native int hashCode();实例：
public class Person {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public int hashCode() {
int result = 17; // 设置一个初始值
result = 31 * result + name.hashCode(); // 根据name属性计算哈希码
result = 31 * result + age; // 根据age属性计算哈希码
return result;
}
// 省略equals()方法的实现
}
4.内部类
4.1概念
内部类是指在一个类的内部定义的另一个类。内部类可以访问外部类的成员，包括私有成员，而外部类不能直接访问内部类的成员。内部类提供了一种封装和组织代码的方式。
4.2分类
内部类可以分为以下几种类型：
- 成员内部类（Member Inner Class）：定义在类的内部，并且成员内部类可以使用外部类的成员。
- 静态内部类（Static Inner Class）：定义在类的内部，但被声明为静态。静态内部类可以直接访问外部类的静态成员，而不需要创建外部类的实例。
- 方法内部类（Method Local Inner Class）：定义在方法内部的类，只能在方法内部访问，且只能在方法被调用时才能创建对象。
- 匿名内部类（Anonymous Inner Class）：没有名字的内部类，通常用于创建只使用一次的类。
4.3实例
下面是一个示例：
public class OuterClass {
private int outerField;
public void outerMethod() {
// 方法内部类
class MethodLocalInnerClass {
public void methodLocalInnerMethod() {
System.out.println("Method Local Inner Class");
}
}
MethodLocalInnerClass inner = new MethodLocalInnerClass();
inner.methodLocalInnerMethod();
}
// 成员内部类
public class MemberInnerClass {
public void memberInnerMethod() {
System.out.println("Member Inner Class");
System.out.println("Outer Field Value: " + outerField);
}
}
// 静态内部类
public static class StaticInnerClass {
public void staticInnerMethod() {
System.out.println("Static Inner Class");
}
}
public void outerClassMethod() {
// 匿名内部类
Runnable runnable = new Runnable() {
@Override
public void run() {
System.out.println("Anonymous Inner Class");
}
};
runnable.run();
}
}
在上面的示例中，我们定义了一个外部类OuterClass，并在其中定义了不同类型的内部类。
要访问成员内部类和静态内部类，我们可以通过外部类的实例来创建内部类对象，如下所示：
OuterClass outer = new OuterClass();
OuterClass.MemberInnerClass inner1 = outer.new MemberInnerClass();
// 创建成员内部类对象
inner1.memberInnerMethod();
OuterClass.StaticInnerClass inner2 = new OuterClass.StaticInnerClass();
// 创建静态内部类对象
inner2.staticInnerMethod();
方法内部类只能在方法内部访问和创建对象，如下所示：
OuterClass outer = new OuterClass();
outer.outerMethod(); // 调用方法内部类
匿名内部类通常用于实现接口或抽象类的匿名实现，如下所示：
OuterClass outer = new OuterClass();
outer.outerClassMethod(); // 调用匿名内部类
内部类的使用可以提高代码的灵活性和封装性，特别是在某个类只在一个类中使用时，可以将其定义为内部类，减少类的数量和代码的复杂性。
2301
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
