抽象類
抽象類概述
在Java中，一個沒有方法體的方法應該定義為抽象方法，而類中如果有抽象方法，該類必須定義為抽象類，
抽象類特點
a.抽象類和抽象方法必須用abstract關鍵字修飾
格式:
abstract class 類名 {}
public abstract void eat(); （抽象方法)
b.抽象類不一定有抽象方法，有抽象方法的類一定是抽象類
c.抽象類不能實體化
那么，抽象類如何實體化呢? 按照多型的方式，由具體的子類實體化，其實這也是多型的一種，抽象類多型，
d.抽象類的子類
要么是抽象類
要么重寫抽象類中的所有抽象方法
例：
abstract class Animals2{ //定義一個抽象的動物類
public abstract void eat(); //定義一個抽象的方法
public abstract void character(); //定義父類的第二個抽象方法
}
class Sheep2 extends Animals2{
@Override
public void eat(){
System.out.println("羊吃草"); //重寫父類中的抽象方法
}
@Override
public void character() {
System.out.println("羊很溫順");
}
}
class Wolf2 extends Animals2{
@Override
public void eat(){
System.out.println("狼吃肉"); //重寫父類中的抽象方法
}
@Override
public void character() {
System.out.println("狼很殘暴");
}
}
public class Test4 {
public static void main(String[] args) {
//多型創建物件
Animals2 s=new Sheep2();
s.eat();
s.character();
Animals2 w =new Wolf2();
w.eat();
w.character();
}
}
抽象類的成員特點
a.成員變數
可以是變數
也可以是常量
b.構造方法
有構造方法，但是不能實體化
那么，構造方法的作用是什么呢? 用于子類訪問父類資料的初始化
c.成員方法
可以有抽象方法 限定子類必須完成某些動作
也可以有非抽象方法 提高代碼服用性
案例：假如我們在開發一個系統時需要對員工類進行設計，員工包含3個屬性：姓名、工號以及工資， 經理也是員工，除了含有員工的屬性外，另為還有一個獎金屬性， 請使用繼承的思想設計出員工類和經理類，要求類中提供必要的方法進行屬性訪問，
abstract class Staff{
//定義員工的成員變數
private String name;
private String number;
private int wage;
public Staff() {
} //無參構造方法
public Staff(String name, String number, int wage) { //有參構造方法
this.name = name;
this.number = number;
this.wage = wage;
}
//get方法
public String getName() {
return name;
}
public String getNumber() {
return number;
}
public int getWage() {
return wage;
}
public abstract void work(); //定義父類抽象方法
public void show(){
System.out.println("姓名："+name);
System.out.println("工號："+number);
System.out.println("工資："+wage);
}
}
class Manager extends Staff{ //經理類
private int bonus; //經理特有的獎金屬性
public Manager(String name, String number, int wage, int bonus) { //子類有參構造方法
super(name, number, wage);
this.bonus = bonus;
}
@Override
public void work() {
System.out.println("作業：管理員工"); //重寫抽象類方法
}
public void show2(){
System.out.println("獎金："+bonus);
}
}
class GeneralStaff extends Staff{ //普通員工類
public GeneralStaff(String name, String number, int wage) {
super(name, number, wage);
}
@Override
public void work() {
System.out.println("作業：寫程式");
}
}
public class Test5 {
public static void main(String[] args) {
//多型創建經理物件
Staff s1 =new Manager("經理","00001",100000,20000);
s1.show();
s1.work();
//向下轉型,訪問子類特有方法
Manager manager= (Manager) s1;
manager.show2();
System.out.println("================================");
//多型創建普通員工物件
Staff s2 =new GeneralStaff("普通員工","00002",20000);
s2.show();
s2.work();
}
}
抽象類中的問題
a.一個類沒有抽象方法能不能定義為抽象類？如果有，有何意義？
可以，例如水和飲料都有共同的特點，我們把這些相同的概念歸結成一個類，都是液體，至于后面有沒有抽象方法，取決于他們有沒有共同的功能，如果只是有相同的本質，沒有實際相同的行為，我們只定義抽象類不寫抽象方法是可以的，
b.abstract不能和哪些關鍵字共存
private 沖突
final 沖突
static 無意義
介面
介面特點
a.介面用關鍵字interface表示
格式：interface 介面名 {}
b.類實作介面用implements表示
格式：class 類名 implements 介面名 {}
c.介面不能實體化
那么，介面如何實體化呢? 按照多型的方式，由具體的子類實體化，其實這也是多型的一種，介面多型，
d.介面的子類
要么是抽象類
要么重寫介面中的所有抽象方法
例：
abstract class OldPhone{ //定義一個抽象的父類
public abstract void call();
}
interface Phone{ //定義一個介面Phone
public void play();
}
class NewPhone extends OldPhone implements Phone{ //定義一個OldPhone類繼承NewPhone類并實作介面
@Override
public void call() {
System.out.println("打電話"); //重寫父類中的抽象方法
}
@Override
public void play() {
System.out.println("玩游戲"); //重寫介面里面的方法
}
public void watch(){
System.out.println("看視頻"); //子類特有方法
}
}
public class interfaceTest1 {
public static void main(String[] args) {
//多型創建NewPhone的物件
OldPhone a= new NewPhone();
a.call();
//OldPhone里沒有play和watch的方法，向下轉型
NewPhone b =(NewPhone) a;
b.play();
b.watch();
}
}
介面成員特點
a.成員變數
只能是常量 默認修飾符 public static final
例：
interface A{
int s= 100;
}
class B implements A{
}
public class interfaceTest2 {
public static void main(String[] args) {
A a= new B();
a.s=1000;
}
}
我們通過Java反編譯工具可以看到這里隱藏的修飾
b.構造方法
沒有，因為介面主要是擴展功能的，而沒有具體存在
（雖然介面中沒有構造方法，但多型初始化的時候會先初始化父類在初始化子類，java中所有的類都有一個父類叫Object，每個class都有Object作為父類）
c.成員方法
只能是抽象方法 默認修飾符 public abstract
例：同樣 我們可以在介面例添加一個方法，通過反編譯工具看到隱藏的修飾
類與類,類與介面以及介面與介面的關系
a.類與類
繼承關系，只能單繼承，但是可以多層繼承
class A1{}
class B1 extends A1{}
class C1 extends B1{}
b.類與介面
實作關系，可以單實作，也可以多實作，還可以在繼承一個類的同時實作多個介面
interface Inter1{}
interface Inter2{}
class C extends Object implements Inter1,Inter2{}c.介面與介面
繼承關系，可以單繼承，也可以多繼承
interface Inter1{}
interface Inter2{}
interface Inter3 extends Inter1,Inter2{}抽象類和介面的區別
1. 成員區別
a.抽象類 : 變數,常量;有抽象方法;抽象方法,非抽象方法
b.介面: 常量;抽象方法
2.關系區別
a.類與類 :繼承，單繼承
b.類與介面: 實作，單實作，多實作
c.介面與介面 :繼承，單繼承，多繼承
3.設計理念區別
a.抽象類 被繼承體現的是：”is a”的關系，共性功能
b.介面 被實作體現的是：”like a”的關系，擴展功能
教練和運動員案例：
a.乒乓球運動員和籃球運動員;乒乓球教練和籃球教練，
b.為了出國交流，跟乒乓球相關的人員都需要學習英語，
c.請用所學知識： 分析，這個案例中有哪些抽象類，哪些介面，哪些具體類，
abstract class Person{ //定義一個抽象的人類
private String name;
private int age; //定義成員變數
public Person() {} //無參構造方法
public Person(String name, int age) { //有參構造方法 （快捷鍵alt+insert）
this.name = name;
this.age = age;
}
//set和get方法
public String getName() {
return name;
}
public int getAge() {
return age;
}
public void setName(String name) {
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
public void show(){ //定義一個展示的方法
System.out.println("姓名："+name+",年齡："+age);
}
}
class SportsMan extends Person{ //創建運動員類繼承人類
//無參，有參構造方法
public SportsMan() {}
public SportsMan(String name, int age) {
super(name, age);
}
}
class Coach extends Person{ //創建教練類繼承人類
//有參，無參構造方法
public Coach() {}
public Coach(String name, int age) {
super(name, age);
}
}
interface English{ //創建一個English介面
public abstract void study(); //這里即使寫不寫abstract都一樣，默認abstract修飾，初學者可以寫一下，
}
class PingPongSports extends SportsMan implements English{ //創建乒乓球運動員類繼承SportsMan類并實作English介面
public PingPongSports(String name, int age) {
super(name, age);
}
@Override //重寫介面中的抽象方法（快捷鍵 alt+Enter）
public void study() {
System.out.println("乒乓球運動員學習英語");
}
}
class BasketballSports extends SportsMan{ //創建籃球運動員繼承SportsMan類
public BasketballSports(String name, int age) {
super(name, age);
}
}
class PingPongCoach extends Coach implements English{ //創建乒乓球教練類繼承SportsMan類并實作English介面
public PingPongCoach(String name, int age) {
super(name, age);
}
@Override //重寫介面中的抽象方法
public void study() {
System.out.println("乒乓球教練學習英語");
}
}
class BasketballCoach extends Coach{ //創建籃球教練繼承教練類
public BasketballCoach(String name, int age) {
super(name, age);
}
}
public class interfaceTest3 {
public static void main(String[] args) {
//創建一個乒乓球運動員物件
SportsMan s1 = new PingPongSports("乒乓球運動員",18);
s1.show();
//向下轉型，訪問子類特有方法
PingPongSports p =(PingPongSports) s1;
p.study(); // ((PingPongSports) s1).study() ，把這兩個合成一個都行
System.out.println("=================");
//創建一個籃球教練的物件
Coach s2 =new BasketballCoach("籃球教練",40);
s2.show();
}
}
轉載請註明出處，本文鏈接：https://www.uj5u.com/qita/420020.html
標籤：其他
上一篇：用戶畫像基礎之用戶畫像是什么