1.3 抽象类语法

1.被 abstract 修饰的类--抽象类

2.抽象类中被 abstract 修饰的方法--抽象方法，该方法不用给出具体的实现体

3.当一个类中含有抽象方法时，该类必须要abstract修饰

4.抽象类也是类，内部可以包含普通方法和属性，甚至构造方法

// 抽象类：被abstract修饰的类public abstract class Shape {// 抽象方法：被abstract修饰的方法，没有方法体abstract public void draw();
abstract void calcArea();// 抽象类也是类，也可以增加普通方法和属性public double getArea(){return area;}protected double area; // 面积
}

1.4 抽象类特性

1. 不能直接实例化对象

public abstract class Shape {
abstract public void draw();
abstract void calcArea();public double getArea(){return area;}protected double area; // 面积
}public static void main(String[] args) {Shape shape = new Shape();
}
// 编译出错
Error:(30, 23) java: Shape是抽象的; 无法实例化

2. 抽象方法1

不能是 private 的

abstract class Shape {
abstract private void draw();
}
// 编译出错
Error:(4, 27) java: 非法的修饰符组合: abstract和private

3. 抽象方法2

2不能被final和static修饰，因为抽象方法要被子类重写

public abstract class Shape {
abstract final void methodA();
abstract public static void methodB();
}
// 编译报错：
// Error:(20, 25) java: 非法的修饰符组合: abstract和final
// Error:(21, 33) java: 非法的修饰符组合: abstract和static

4. 抽象类必需被继承

继承后的子类要重写父类的抽象方法，如果子类不重写父类中的抽象方法，那么子类也会成为抽象类，并且必须用 abstract 关键字进行修饰

// 矩形类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(); // 编译失败：要么实现该抽象方法，要么将三角形设计为抽象类
}

5. 抽象类中的包含方法

不一定包含抽象方法，但是有抽象方法的类一定是抽象类

6. 抽象类有构造方法

供子类创建对象时，初始化父类的成员变量

abstract class AbstractBase {// 抽象类中不一定包含抽象方法，这里没有抽象方法int someVariable;public AbstractBase(int someValue) {// 抽象类中有构造方法，供子类创建对象时初始化父类成员变量someVariable = someValue;}
}class ConcreteSubclass extends AbstractBase {public ConcreteSubclass(int value) {super(value);}
}

1.5 抽象类的作用

2. 接口

2.1 接口的概念

abstract class Animal {abstract void makeSound();
}class Dog extends Animal {void makeSound() {System.out.println("Woof");}
}class Cat extends Animal {void makeSound() {System.out.println("Meow");}
}public class Test {public static void main(String[] args) {Animal myAnimal = new Dog();myAnimal.makeSound(); // 输出 "Woof"myAnimal = new Cat();myAnimal.makeSound(); // 输出 "Meow"}
}

2.2.11注意

提示:

1. 创建接口时, 接口的命名一般以大写字母 I 开头.

2. 接口的命名一般使用 "形容词" 词性的单词.

 interface IFlying {void fly();}interface IRunning {void run();}interface ISwimming {void swim();}

举例子：猫, 是会跑的.

class Cat extends Animal implements IRunning {public Cat(String name) {super(name);}@Overridepublic void run() {System.out.println(this.name + "正在用四条腿跑");}}

鱼, 是会游的.

class Fish extends Animal implements ISwimming {public Fish(String name) {super(name);}@Overridepublic void swim() {System.out.println(this.name + "正在用尾巴游泳");}}

小鸟会飞

class Brid extends Animal implements port.IFlying {public Brid(String name) {super(name);}@Overridepublic void fly() {System.out.println(this.name+" 在飞翔着");}
}

注意：一个类实现多个接口时，每个接口中的抽象方法都要实现，否则类必须设置为抽象类。

快捷实现接口按键ctrl+i

上诉代码优化

猫，鱼，鸟都是会跑的，所有引用时候可以将

cat.run();换成walk(run)

优化优点：有了接口之后, 类的使用者就不必关注具体类型,

2.6 接口间的继承

接口可以继承一个接口, 达到复用的效果. 使用 extends 关键字.

interface IRunning {void run();}interface ISwimming {void swim();}// 两栖的动物, 既能跑, 也能游
interface IAmphibious extends IRunning, ISwimming {}class Frog implements IAmphibious {...}

2.7 抽象类和接口的区别

 核心区别:

抽象类中可以包含普通方法和普通字段, 这样的普通方法和字段可以被子类直接使用(不必重写)

接口中不能包含普通方法, 子类必须重写所有的抽象方法.

如之前写的 Animal 例子. 此处的 Animal 中包含一个 name 这样的属性, 这个属性在任何子类中都是存在的. 因此此处的 Animal 只能作为一个抽象类, 而不应该成为一个接口

 class Animal {protected String name;public Animal(String name) {this.name = name;}}

3. Object类

Object是Java默认提供的一个类。Java里面除了Object类，所有的类都是存在继承关系的。默认会继承Object父 类。即所有类的对象都可以使用Object的引用进行接收。

范例：使用Object接收所有类的对象

class Person{}class Student{}public class Test {public static void main(String[] args) {function(new Person());function(new Student());}public static void function(Object obj) {System.out.println(obj);}}//执行结果：
Person@1b6d3586Student@4554617c

Object类是参数的最高统一类型。但是Object类也存在有定义好的一些方法。如下：

本小节当中，我们主要来熟悉这几个方法：toString()方法，equals()方法，hashcode()方法

3.1 获取对象信息

如果要打印对象中的内容，可以直接重写Object类中的toString()方法，之前已经讲过了，此处不再累赘。

// Object类中的toString()方法实现：
public String toString() {return getClass().getName() + "@" + Integer.toHexString(hashCode());}

// 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);             // 输出trueSystem.out.println(p1 == p2);           // 输出falseSystem.out.println(p1.equals(p2));      // 输出false}}

Person类重写equals方法后，然后比较：

class Person{...@Overridepublic 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方法。

public String toString() {return getClass().getName() + "@" + Integer.toHexString(hashCode());}

hashcode方法源码：

public native int hashCode();

我们认为两个名字相同，年龄相同的对象，将存储在同一个位置，如果不重写hashcode()方法，我们可以来看示例 代码：

class Person {public String name;public int age;public Person(String name, int age) {this.name = name;this.age = age;}}public class TestDemo4 {public static void main(String[] args) {Person per1 = new Person("gaobo", 20) ;Person per2 = new Person("gaobo", 20) ;System.out.println(per1.hashCode());System.out.println(per2.hashCode());}}//执行结果
4601419581163157884

注意事项：两个对象的hash值不一样。

class Person {public String name;public int age;public Person(String name, int age) {this.name = name;this.age = age;}@Overridepublic int hashCode() {return Objects.hash(name, age);}}public class TestDemo4 {public static void main(String[] args) {Person per1 = new Person("gaobo", 20) ;Person per2 = new Person("gaobo", 20) ;System.out.println(per1.hashCode());System.out.println(per2.hashCode());}}//执行结果
460141958460141958

结论：

1、hashcode方法用来确定对象在内存中存储的位置是否相同

2、事实上hashCode() 在散列表中才有用，在其它情况下没用。在散列表中hashCode() 的作用是获取对象的散列码，进而确定该对象在散列表中的位置。

抽象类：
- 抽象类是一种不能被实例化的类，它通常包含一个或多个抽象方法，这些方法只有声明没有实现，子类必须提供这些方法的具体实现。
- 抽象类可以包含具体方法和变量，这些具体方法可以被子类直接继承和使用。
- 抽象类使用`abstract`关键字声明，它可以有构造方法，但这些构造方法只能被子类调用。
- 抽象类适用于有共同特性和行为的对象，但具体实现需要在子类中完成的情况。

接口：
- 接口是一种完全抽象的类，它定义了一组方法规范，但不提供实现。从Java 8开始，接口可以包含默认方法和静态方法。
- 接口使用`interface`关键字声明，所有方法默认是`public`的，并且从Java 9开始，默认也是`abstract`的。
- 一个类可以实现多个接口，这提供了一种实现多重继承的方式。
- 接口适用于定义操作规范，而具体实现由实现接口的类来完成，这有助于代码的解耦和模块化。

区分
- 抽象类和接口都是定义行为规范的工具，但抽象类更侧重于共享代码和提供默认实现，而接口则侧重于定义操作规范。
- 选择使用抽象类还是接口取决于具体需求。如果需要共享代码，并且类层次结构相对固定，抽象类是更好的选择。如果需要实现多重继承，或者希望代码更加模块化和解耦，接口是更好的选择。
- 在实际开发中，抽象类和接口往往结合使用，以实现复杂的功能和灵活的设计。

通过合理使用抽象类和接口，可以提高代码的可读性、可维护性和可扩展性，同时也能够更好地利用Java的面向对象特性。
 

希望这篇文章可以帮助到读者更好的了解相关内容。