# 大數據學習筆記第8天 - 面向對象2 #
## 大綱
- 接口
- 多態
- 抽象類
- 內部類
- 匿名類
## 代碼實例
E:\01\Java\day08\day08\day08\Demo2.java
/*
抽象類多態
*/
abstract class A{
//成員變量沒有多態性
int num = 10;
public abstract void show();
//靜態方法
public static void method(){
System.out.println("A.method()...");
}
}
class B extends A{
int num = 20;
public void show(){
System.out.println("B.show()...");
}
//子類特有的方法
public void test(){
System.out.println("B.test()...");
}
//靜態方法
public static void method(){
System.out.println("B.method()...");
}
}
//
class Animal{
}
class Dog extends Animal{
public void eat(){
System.out.println("dog.eat()...");
}
}
public class Demo2{
public static void main(String[] args){
Animal an = new Dog();
// an.eat();
Dog d = (Dog)an;//向下類型轉換
d.eat();
//抽象類多態(向上類型轉換)
// A a = new B();
// a.method();//靜態方法沒有多態性
// System.out.println(a.num);//成員變量沒有多態性
// a.show();
// a.test();//站在抽象類角度,沒有test方法,不能調用
}
}
E:\01\Java\day08\day08\day08\HomeWork.java
/*
定義一個抽象的運動員類,包含一個抽象方法:practice.
定義兩個實現子類:籃球運動員,足球運動員繼承自運動員抽象類.
定義接口:SpeakEnglish,包含抽象方法:speakEnglish.籃球運動員需要實現接口.
用代碼實現以上邏輯并做測試.
*/
//
abstract class Sporter{
//
public abstract void practice();
}
interface SpeakEnglish{
public abstract void speakEnglish();
}
class BasketballSporter extends Sporter implements SpeakEnglish{
public void practice(){
System.out.println("籃球運動員訓練");
}
public void speakEnglish(){
System.out.println("籃球運動員可以說英語");
}
}
class FootballSporter extends Sporter{
public void practice(){
System.out.println("足球運動員訓練");
}
}
//測試類
public class HomeWork{
public static void main(String[] args){
BasketballSporter bs = new BasketballSporter();
bs.practice();
bs.speakEnglish();
FootballSporter fs = new FootballSporter();
fs.practice();
}
}
E:\01\Java\day08\day08\day08\InnerClassDemo.java
/*
定義在類中的類稱為內部類,外邊的類稱為外部類.
內部類:
成員內部類:
局部內部類:
*/
class Outer{
private int a = 10;
public int b = 20;
static int c = 30;
//非靜態的成員內部類,可以使用外部類的靜態和非靜態成員
class Inner{
//非靜態內部類不能定義靜態成員(變量,方法)
// static int num1 = 10;
int num2 = 20;
public void show(){
System.out.println(a +","+ b +"," + c);
}
}
//靜態內部類:可以定義靜態成員
static class Inner2{
static int num3 = 30;
int num4 = 40;
//只能訪問外部類的靜態成員
public void show(){
System.out.println(c);
}
}
public void test(){
//局部內部類
class A{
public void show(){
System.out.println(a +","+ b +"," + c);
}
}
}
}
//
public class InnerClassDemo{
public static void main(String[] args){
//Inner
Outer.Inner in1 = new Outer().new Inner();
in1.show();
//Inner2
Outer.Inner2 in2 = new Outer.Inner2();
in2.show();
}
}
E:\01\Java\day08\day08\day08\InnerClassDemo2.java
/*
內部類的主要應用:
實現接口或者繼承父類
*/
abstract class Animal{
public abstract void eat();
}
interface A{
public abstract void method();
}
class Test{
public void test(Animal an){//an = ... //抽象類多態
an.eat();
}
public void test2(A a){
a.method();
}
}
//第一版代碼:寫一個真正的實現類
/*
class Dog extends Animal{
public void eat(){
System.out.println("Dog.eat()...");
}
}
*/
//測試類
public class InnerClassDemo2{
/*
第二版代碼:
用內部類的形式實現繼承抽象類
*/
/*
static class Dog extends Animal{
public void eat(){
System.out.println("Dog.eat()...");
}
}
*/
public static void main(String[] args){
Test t = new Test();
// Dog d = new Dog();
//實現抽象類中的抽象方法,和創建對象一次完成:匿名內部類
t.test(new Animal(){
public void eat(){
System.out.println("Dog.eat()...");
}
});
//匿名內部類對象,實現接口
t.test2(new A(){
public void method(){
System.out.println("A.method()...");
}
});
}
}
E:\01\Java\day08\day08\day08\InterfaceDemo1.java
/*
接口和接口之間是繼承關系:
多個接口中的共同部分可以抽取出來到一個單獨的接口中
實現類和接口間的關系:implements
實現類和抽象類之間的關系:extends
抽象類和接口之間的關系:extends
接口和接口之間的關系:extends
*/
interface A{
public static final int a = 10;
public abstract void m1();
}
interface B{
public abstract void m2();
}
interface C extends A,B{
}
class D implements C{
public void m1(){
System.out.println("m1()");
}
public void m2(){
System.out.println("m2()");
}
}
public class InterfaceDemo1{
public static void main(String[] args){
/* D d = new D();
d.m1();
d.m2(); */
//直接使用接口中的常量
// System.out.println(A.a);
//接口多態:接口類型的變量,指向子類實例對象
A a = new D();
a.m1();
}
}
E:\01\Java\day08\day08\day08\InterfaceDemo2.java
/*
接口使用場景:
1.接口作為形參類型
實際傳遞的是實現子類的對象
2.接口作為返回值類型
實際返回的是實現子類的對象
*/
interface A{
public abstract void show();
}
class B implements A{
public void show(){
System.out.println("B.show()...");
}
}
class Test{
public void test(A a){//相當于有一條賦值語句: a = ...
a.show(); //既然a指向的是一個實現類的對象,就可以調用show方法
}
public A getA(){
return new B();
}
}
//測試類
public class InterfaceDemo2{
public static void main(String[] args){
B b = new B();
Test t = new Test();
t.test(b);//B.show()...
//方法的返回值是接口類型,實際返回的是實現子類的對象
//接口類型的變量 指向了實現子類的實例對象(接口多態)
A a = t.getA();
a.show();//B.show()... 既然a指向的是一個實現類的對象,就可以調用show方法
}
}
*E:\01\Java\day08\day08\day08\PolymorphismDemo.java*
/*
多態:同一個變量的不同形態
普通類多態:
父類和子類都是普通類
抽象類多態:
抽象類和實現子類之間的多態
接口多態:
接口和實現子類之間的多態
*/
class Animal{
public void eat(){
System.out.println("animal eat()...");
}
}
class Dog extends Animal{
public void eat(){
System.out.println("Dog eat()...");
}
//子類特有的方法
public void test(){
System.out.println("Dog test()...");
}
}
class Cat extends Animal{
public void eat(){
System.out.println("Cat eat()...");
}
//子類特有的方法
public void test(){
System.out.println("Cat test()...");
}
}
//
public class PolymorphismDemo{
public static void main(String[] args){
//變量類型和實例對象類型一致.編譯期類型和運行期類型相同
Animal an = new Animal();
an.eat();
//父類類型的變量指向的是子類實例對象
//=左邊是編譯期類型,右邊是運行時類型
Animal an2 = new Dog();
an2.eat();//
an2.test();//找不到符號,站在父類的角度看,看不到test方法.
/*
an2 = new Cat();
an2.eat();//
*/
}
}
