# 大数据学习笔记第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();//
*/
}
}
