抽象類和介面
- 抽象類
- 語法規則
- 注意事項
- 介面
- 理解介面
- 常見的兩個介面
- Comparable
- Comparator
- Cloneable
抽象類
語法規則
沒有實際作業的方法, 比如上篇文章的Shape類， 我們可以把它設計成一個 抽象方法(abstractmethod), 包含抽象方法的類我們稱為 抽象類(abstract class)
abstract class Shape {
abstract public void draw();
}
- 在 draw 方法前加上 abstract 關鍵字, 表示這是一個抽象方法. 同時抽象方法沒有方法體(沒有 { }, 不能執行具體代碼)
- 對于包含抽象方法的類, 必須加上 abstract 關鍵字表示這是一個抽象類
注意事項
- 抽象類不能直接實體化
Shape shape = new Shape();
// 編譯出錯
Error:(30, 23) java: Shape是抽象的; 無法實體化
- 在抽象類中，可以擁有和普通類一樣的資料成員和方法
abstract class Shape {
int count;
public static float sum;
public abstract void draw();
public int bian(){
return count;
}
}
- 抽象類是可以被繼承的，發生向上轉型，動態系結以及多型
abstract class Shape1 {
public abstract void draw();
}
class Cricle1 extends Shape1 {
@Override
public void draw() {
System.out.println("?");
}
}
public class Demo {
public static void drawMap(Shape1 shape1) {
shape1.draw();;
}
public static void main(String[] args) {
Cricle1 cricle1 = new Cricle1();
drawMap(cricle1);
}
}
- 當一個普通類繼承了一個抽象類，那么這么普通類一定要重寫抽象類中的抽象方法，
//子類中沒有重寫Shape1中的draw抽象方法
class Cricle1 extends Shape1 {
}
此時會報錯
- 當普通類繼承了抽象類，且不想實作抽象類中的抽象方法的時候，那么這個普通類可以被修改為抽象類，此時就不需要進行實作了，當然也可以實作
abstract class Cricle1 extends Shape1 {
}
這時就沒有報錯了
- 抽象方法不能是private修飾的，因為抽象方法就是用來被重寫的
abstract class Shape1 {
private abstract void draw();
}
- 抽象類存在的最大意義就是為了被繼承
介面
使用關鍵字interface
interface IShape {
void draw();
}
- 介面當中的方法，不能有具體實作
介面當中的方法，默認是：public abstract
interface IShape {
public abstract void draw();
void write();
}
- 介面當中的成員變數，默認是public static final
interface IShape {
public static final int age = 10;
int age2 = 20;
}
- JDK1.8引入的新特性，default修飾的方法，為默認方法，可以有具體的實作
interface IShape {
public static final int age = 10;
int age2 = 20;
public abstract void draw();
void write();
}
- 介面和抽象類一樣，是不能實體化的
- 類和介面的關系是，implements，而不是用extends
class Flower1 implements IShape{
@Override
public void draw() {
System.out.println("?");
}
}
- 介面也是可以被繼承的，發生向上轉型，動態系結以及多型
interface IShape {
void draw();
}
class Flower1 implements IShape{
@Override
public void draw() {
System.out.println("?");
}
}
class Rect1 implements IShape {
@Override
public void draw() {
System.out.println("?");
}
}
public class Demo2 {
public static void drawMap(IShape iShape) {
iShape.draw();
}
public static void main(String[] args) {
IShape iShape = new Flower1();
drawMap(iShape);
drawMap(new Rect1());
}
}
- 一個類可以實作多個介面
interface A {
void funcA();
}
interface B {
void funcB();
}
interface C {
void funcC();
}
class Test implements A,B,C {
@Override
public void funcA() {
}
@Override
public void funcB() {
}
@Override
public void funcC() {
}
}
- 一個類可以繼承類，同時實作多個介面
interface A {
void funcA();
}
interface B {
void funcB();
}
interface C {
void funcC();
}
abstract class TestAbstrect {
public abstract void testAbstrect();
}
class Test extends TestAbstrect implements A,B,C {
@Override
public void funcA() {
}
@Override
public void funcB() {
}
@Override
public void funcC() {
}
@Override
public void testAbstrect() {
}
}
- 介面可以擴展多個介面
interface A {
void funcA();
}
interface B {
void funcB();
}
interface C {
void funcC();
}
interface D extends A,B,C{
void funcD();
}
class F implements D {
@Override
public void funcA() {
}
@Override
public void funcB() {
}
@Override
public void funcC() {
}
@Override
public void funcD() {
}
}
- 所以介面的作用就是解決java多繼承的問題
理解介面
看一個例子
interface IFlying {
void fly();
}
interface IRunning {
void run();
}
interface ISwimming {
void swim();
}
class Animal {
protected String name;
public Animal(String name) {
this.name = name;
}
}
class Cat extends Animal implements IRunning{
public Cat(String name) {
super(name);
}
@Override
public void run() {
System.out.println(this.name + "跑");
}
}
class Fish extends Animal implements ISwimming {
public Fish(String name) {
super(name);
}
@Override
public void swim() {
System.out.println(this.name + "游");
}
}
class Duck extends Animal implements IRunning,ISwimming,IFlying {
public Duck(String name) {
super(name);
}
@Override
public void fly() {
System.out.println(this.name + "飛");
}
@Override
public void run() {
System.out.println(this.name + "跑");
}
@Override
public void swim() {
System.out.println(this.name + "游");
}
}
public class Demo4 {
public static void main(String[] args) {
IRunning iRunning = new Duck("唐老鴨");
iRunning.run();
IFlying iFlying = new Duck("唐老鴨");
iFlying.fly();
ISwimming iSwimming = new Duck("唐老鴨");
iSwimming.swim();
}
}
主函式也可以這樣寫
public class Demo5 {
public static void goRun(IRunning iRunning) {
iRunning.run();
}
public static void goFly(IFlying iFlying) {
iFlying.fly();
}
public static void goSwim(ISwimming iSwimming) {
iSwimming.swim();
}
public static void main(String[] args) {
Duck duck = new Duck("唐老鴨");
goRun(duck);
goFly(duck);
goSwim(duck);
}
}
這樣設計有什么好處呢?
時刻牢記多型的好處, 讓程式猿忘記型別. 有了介面之后, 類的使用者就不必關注具體型別, 而只關注某個類是否具備某種能力
常見的兩個介面
Comparable
class Student implements Comparable<Student>{
public String name;
public int score;
public Student(String name, int score) {
this.name = name;
this.score = score;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", score=" + score +
'}';
}
@Override
public int compareTo(Student o) {
if(this.score > o.score) {
return 1;
}else if(this.score == o.score) {
return 0;
}else {
return -1;
}
}
}
public class Demo5 {
public static void main(String[] args) {
Student[] students = new Student[3];
students[0] = new Student("星星",21);
students[1] = new Student("狒狒",12);
students[2] = new Student("朵朵",23);
System.out.println(Arrays.toString(students));
System.out.println("============排序=============");
Arrays.sort(students);
System.out.println(Arrays.toString(students));
}
}
此時就會按照成績排序
Comparator
比較器：一般在類外定義
//分數比較器
public class ScoreComparator implements Comparator<Student1> {
@Override
public int compare(Student1 o1, Student1 o2) {
return o1.score - o2.score;
}
}
//姓名比較器
public class NameComparator implements Comparator<Student1> {
@Override
public int compare(Student1 o1, Student1 o2) {
return o1.name.compareTo(o2.name);
}
}
class Student1{
public String name;
public int score;
public Student1(String name, int score) {
this.name = name;
this.score = score;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", score=" + score +
'}';
}
}
public class Demo6 {
public static void main(String[] args) {
Student1[] students = new Student1[3];
students[0] = new Student1("星星",21);
students[1] = new Student1("狒狒",12);
students[2] = new Student1("朵朵",23);
System.out.println(Arrays.toString(students));
System.out.println("============根據分數排序=============");
ScoreComparator scoreComparator = new ScoreComparator();
Arrays.sort(students, scoreComparator);
System.out.println(Arrays.toString(students));
System.out.println("============根據姓名排序=============");
NameComparator nameComparator = new NameComparator();
Arrays.sort(students, nameComparator);
System.out.println(Arrays.toString(students));
}
}
Cloneable
深拷貝：
class Person implements Cloneable {
public String name;
public int age;
public Person(String name) {
this.name = name;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
public class Demo7 {
public static void main(String[] args) throws CloneNotSupportedException {
Person person1 = new Person("星星");
Person person2 = (Person) person1.clone();
System.out.println(person1.name);
System.out.println(person2.name);
System.out.println("============修改name=============");
person2.name = "狒狒";
System.out.println(person1.name);
System.out.println(person2.name);
}
}
淺拷貝：
class Money {
public double money = 12.8;
}
class Person implements Cloneable {
public String name;
public Money m = new Money();
public Person(String name) {
this.name = name;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
'}';
}
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
public class Demo7 {
public static void main(String[] args) throws CloneNotSupportedException {
Person person1 = new Person("星星");
Person person2 = (Person) person1.clone();
System.out.println(person1.m.money);
System.out.println(person2.m.money);
System.out.println("============修改name=============");
person2.m.money = 99.99;
System.out.println(person1.m.money);
System.out.println(person2.m.money);
}
}
怎么將上面的代碼變為深拷貝呢
class Money implements Cloneable{
public double money = 12.8;
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
class Person implements Cloneable {
public String name;
public Money m = new Money();
public Person(String name) {
this.name = name;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
'}';
}
@Override
protected Object clone() throws CloneNotSupportedException {
Person person2 = (Person)super.clone();
person2.m = (Money)this.m.clone();
return person2;
}
}
這樣子進行修改后，則達到了深拷貝
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/262187.html
標籤：java
上一篇：Java筆記一