[从0开始学Java|第十五天]面向对象进阶（抽象类&接口&内部类）

抽象类和抽象方法

抽象类和抽象方法的概念

抽象类和抽象方法的定义格式

抽象类和抽象方法的注意事项

例如：

（源代码）

[Person]

package com.itheima.a01abstractdemo1;

public abstract class Person {
private String name;
private int age;

//当创建子类对象时，给属性赋值的
public Person() {
}

public Person(String name, int age) {
this.name = name;
this.age = age;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public int getAge() {
return age;
}

public void setAge(int sge) {
this.age = age;
}

public abstract void work();

public void sleep(){
System.out.println("睡觉");
}
}

[Student]

package com.itheima.a01abstractdemo1;

public class Student extends Person{

public Student() {
}

public Student(String name, int sge) {
super(name, sge);
}

@Override
public void work(){
System.out.println("学生的工作是学习");
}

}

[Test]

package com.itheima.a01abstractdemo1;

public class Test {
public static void main(String[] args) {

Student s = new Student("zhangsan",23);
System.out.println(s.getName() + ", " + s.getAge());
}
}

(运行结果截图)

练习：编写带有抽象类的标准javabean类的

（分析）

(源代码)

[Animal]

package com.itheima.a02abstractdemo2;

public abstract class Animal {
private String name;
private int age;

public Animal() {
}

public Animal(String name, int age) {
this.name = name;
this.age = age;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public int getAge() {
return age;
}

public void setAge(int age) {
this.age = age;
}

public abstract void eat();

public void drink(){
System.out.println("动物在喝水");
}

}

[Frog]

package com.itheima.a02abstractdemo2;

public class Frog extends Animal{

public Frog() {
}

public Frog(String name, int age) {
super(name, age);
}

@Override
public void eat(){
System.out.println("青蛙在吃虫子");
}

}

[Dog]

package com.itheima.a02abstractdemo2;

public class Dog extends Animal{

public Dog() {
}

public Dog(String name, int age) {
super(name, age);
}

@Override
public void eat(){
System.out.println("狗在吃骨头");
}
}

[Sheep]

package com.itheima.a02abstractdemo2;

public class Sheep extends Animal{

public Sheep() {
}

public Sheep(String name, int age) {
super(name, age);
}

@Override
public void eat(){
System.out.println("山羊在吃草");
}

}

[Test]

package com.itheima.a02abstractdemo2;

public class Test {
public static void main(String[] args){

//创建对象
Dog d = new Dog("大黄",1);
System.out.println(d.getName() + ", " + d.getAge());
d.eat();
d.drink();

}
}

(运行结果截图)

抽象类和抽象方法的意义

                                        强制子类必须按照这种格式进行编写

总结

接口

为什么要有接口？

接口的应用

接口和抽象类的异同

                                        接口就是一种规则，是对行为的抽象

接口的定义和使用

练习：编写带有接口和抽象类的标准javabean类

（源代码）

[Animal]

package com.itheima.a01interfacedemo1;

public abstract class Animal {
private String name;
private int age;

public Animal() {
}

public Animal(String name,int age){
this.name = name;
this.age = age;
}

public String getName(){
return name;
}

public void setName(String name){
this.name = name;
}

public int getAge(){
return age;
}

public void setAge(int age){
this.age = age;
}

public abstract void eat();

}

[Swim](接口interface)

package com.itheima.a01interfacedemo1;

public interface Swim {

public abstract void swim();

}

[Rabbit]

package com.itheima.a01interfacedemo1;

public class Rabbit extends Animal{

public Rabbit(){
}

public Rabbit(String name,int age){
super(name,age);
}

@Override
public void eat(){
System.out.println("兔子在吃草");
}

}

[Frog]

package com.itheima.a01interfacedemo1;

public class Frog extends Animal implements Swim{

public Frog() {
}

public Frog(String name, int age) {
super(name, age);
}

@Override
public void eat(){
System.out.println("青蛙在吃虫子");
}

@Override
public void swim(){
System.out.println("青蛙在蛙泳");
}

}

[Dog]

package com.itheima.a01interfacedemo1;

public class Dog extends Animal implements Swim{

public Dog() {
}

public Dog(String name, int age) {
super(name, age);
}

@Override
public void eat(){
System.out.println("狗在吃骨头");
}

@Override
public void swim(){
System.out.println("狗在狗刨");
}

}

[Test]

package com.itheima.a01interfacedemo1;

public class Test {
public static void main(String[] args) {
//创建对象
Dog d = new Dog("大黄",1);
System.out.println(d.getName() + ", " + d.getAge());
d.eat();
d.swim();

Rabbit r = new Rabbit("小白",1);
System.out.println(r.getName() + ", " + r.getAge());
r.eat();

}
}

(运行结果截图)

接口的细节：成员特点和接口的各种关系

接口中成员的特点

接口和类之间的关系

类和接口的关系中的小细节：

        如果同时实现多个接口，就要重写里面所有的抽象方法

接口和接口的关系中的小细节：

        实现类是实现的最下面的子接口的话，需要重写体系中所有的抽象方法

接口和抽象类的综合案例

（分析）

【思路1】

【思路2】（更推荐的方案）

（源代码）

[Person]

package com.itheima.a05interfacedemo5;

public class Person {
private String name;
private int age;

public Person() {
}

public Person(String name, int age) {
this.name = name;
this.age = age;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public int getAge() {
return age;
}

public void setAge(int age) {
this.age = age;
}
}

[English](接口interface)

package com.itheima.a05interfacedemo5;

public interface English {

public abstract void speakEnglish();

}

[Sporter]

package com.itheima.a05interfacedemo5;

public abstract class Sporter extends Person{

public Sporter() {
}

public Sporter(String name, int age) {
super(name, age);
}

public abstract void study();

}

[Coach]

package com.itheima.a05interfacedemo5;

public abstract class Coach extends Person{

public Coach() {
}

public Coach(String name, int age) {
super(name, age);
}

public abstract void teach();

}

[PingPangSporter]

package com.itheima.a05interfacedemo5;

public class PingPangSporter extends Sporter implements English{

public PingPangSporter() {
}

public PingPangSporter(String name, int age) {
super(name, age);
}

@Override
public void study(){
System.out.println("乒乓球运动员在学打乒乓球");
}

@Override
public void speakEnglish(){
System.out.println("乒乓球运动员在说英语");
}

}

[BasketballSporter]

package com.itheima.a05interfacedemo5;

public class BasketballSporter extends Sporter{

public BasketballSporter() {
}

public BasketballSporter(String name, int age) {
super(name, age);
}

@Override
public void study(){
System.out.println("篮球运动员在学打篮球");
}
}

[PingPangCoach]

package com.itheima.a05interfacedemo5;

public class PingPangCoach extends Coach implements English{

public PingPangCoach() {
}

public PingPangCoach(String name, int age) {
super(name, age);
}

@Override
public void teach(){
System.out.println("乒乓球教练在教打乒乓球");
}

@Override
public void speakEnglish(){
System.out.println("乒乓球教练在说英语");
}
}

[BasketballCoach]

package com.itheima.a05interfacedemo5;

public class BasketballCoach extends Coach {

public BasketballCoach() {
}

public BasketballCoach(String name, int age) {
super(name, age);
}

@Override
public void teach(){
System.out.println("篮球教练在教打篮球");
}

}

[Test]

package com.itheima.a05interfacedemo5;

public class Test {
public static void main(String[] args){

PingPangSporter pps = new PingPangSporter("张三",23);
System.out.println(pps.getName() + "," + pps.getAge());
pps.study();
pps.speakEnglish();

BasketballCoach bc = new BasketballCoach("李四",24);
System.out.println(bc.getName() + "," + bc.getAge());
bc.teach();

}
}

（运行结果截图）

多学三招：接口中新增方法，接口应用和适配器设计模式

JDK8开始接口中新增的方法

JDK8新增的方法

JDK8的新特性：默认方法

例如：

（源代码）

[Inter]（接口Interface）

package com.itheima.a06interfacedemo6;

public interface Inter {

public abstract void method();

public default void show(){
System.out.println("接口中的默认方法 — show");
}

}

[InterImp]

package com.itheima.a06interfacedemo6;

import java.sql.SQLOutput;

public class InterImp implements Inter{
@Override
public void method(){
System.out.println("实现类重写的抽象方法");
}

@Override
public void show(){
System.out.println("重写接口中的默认方法");
}

}

[Test]

package com.itheima.a06interfacedemo6;

public class Test {
public static void main(String[] args) {
InterImp ii = new InterImp();
ii.method();
ii.show();
}
}

JDK8的新特性：静态方法

例如：

（源代码）

[Inter]

package com.itheima.a07interfacedemo7;

public interface Inter {
public abstract void method();

public static void show(){
System.out.println("Inter接口中的静态方法");
}

}

[InterImp]

package com.itheima.a07interfacedemo7;

public class InterImp implements Inter{
@Override
public void method(){
System.out.println("InterImp重写的抽象方法");
}

//不叫重写：刚好在实现类中跟接口里面有一个重名的方法
public static void show(){
System.out.println("InterImp重写的抽象方法");
}
}

[Test]

package com.itheima.a07interfacedemo7;

public class Test {
public static void main(String[] args) {
//调用接口中的静态方法
Inter.show();

//调用实现类中的静态方法
InterImp.show();
}
}

(运行结果截图)

JDK9新增的方法

【格式1】：普通的私有方法（给默认方法服务的）

（源代码）

package com.itheima.a08interfacedemo8;

public interface InterA {

//默认方法
public default void show1(){
System.out.println("show1开始执行了");
show3();
}

public default void show2(){
System.out.println("show2开始执行了");
show3();
}

//普通的私有方法，给默认方法服务的
private void show3(){
System.out.println("记录程序在运行中的各种细节，这里有100行代码");
}

}

【格式2】：静态的私有方法（给静态方法服务的）

（源代码）

package com.itheima.a08interfacedemo8;

public interface InterB {
//静态方法
public static void show1(){
System.out.println("show1开始执行了");
show4();
}

public static void show2(){
System.out.println("show2开始执行了");
show4();
}

//静态的私有方法，给静态方法服务的
private static void show4(){
System.out.println("记录程序在运行中的各种细节，这里有100行代码");
}

}

总结

接口的应用

总结

适配器设计模式

设计模式和适配器设计模式的概念

                                        在实现类和接口中添加了第三者

例如：

（源代码）

[Inter]

package com.itheima.a09interfacedemo9;

public interface Inter {
public abstract void method1();
public abstract void method2();
public abstract void method3();
public abstract void method4();
public abstract void method5();
public abstract void method6();
public abstract void method7();
public abstract void method8();
public abstract void method9();
public abstract void method10();
}

[InterAdapter]

package com.itheima.a09interfacedemo9;

public abstract class InterAdapter implements Inter{

@Override
public void method1() {

}

@Override
public void method2() {

}

@Override
public void method3() {

}

@Override
public void method4() {

}

@Override
public void method5() {

}

@Override
public void method6() {

}

@Override
public void method7() {

}

@Override
public void method8() {

}

@Override
public void method9() {

}

@Override
public void method10() {

}
}

[InterImp]

package com.itheima.a09interfacedemo9;

public class InterImp extends InterAdapter{

//需要用到哪个方法，就重写哪个方法
@Override
public void method5(){
System.out.println("只要用method5");
}

}

总结

初识内部类

什么是内部类？

为什么要学习内部类？

例如：

（源代码）

[Car]

package com.itheima.a01interclass1;

public class Car {
String carName;
int carAge;
String carColor;

public void show(Car this){
//是打印调用者车的名字
System.out.println(this.carName);
Engine e = new Engine();
System.out.println(e.engineName);
}

class Engine{
String engineName;
int engineAge;

public void show(){
System.out.println(engineName);
System.out.println(carName);
}
}

}

[Test]

package com.itheima.a01interclass1;

public class Test {
public static void main(String[] args) {

Car c = new Car();
c.carName = "凯迪拉克";
c.carAge = 1;
c.carColor = "黑";

c.show();
}
}

(运行结果截图)

总结

内部类的分类

成员内部类

成员内部类的代码如何书写

如何创建成员内部类的对象

方式一：

        在外部类中编写方法，对外提供内部类的对象（private）

例如：

（源代码）

[Outer]

package com.itheima.a02interclassdemo2;

public class Outer {
String name;

private class Inner{

}

public Inner getInstance(){
return new Inner();
}
}

[Test]

package com.itheima.a02interclassdemo2;

public class Test {
public static void main(String[] args) {

Outer o = new Outer();
System.out.println(o.getInstance());

}
}

方式二：

        直接创建格式：外部类名.内部类名 对象名 = 外部类对象.内部类对象;

        Outer.Inner oi = new Outer().new Inner();

例如：

（源代码）

[Outer]

package com.itheima.a03interclassdemo3;

public class Outer {
String name;

public class Inner{

}

}

[Test]

package com.itheima.a03interclassdemo3;

public class Test {
public static void main(String[] args) {

Outer.Inner oi = new Outer().new Inner();

}
}

成员内部类如何获取成员外部类的成员变量

练习：成员内部类-面试题

（源代码）

[Outer]

package com.itheima.a04interclassdemo4;

public class Outer {
private int a = 10;

class Inner{
private int a = 20;

public void show(){
int a = 30;
System.out.println(Outer.this.a);//10
System.out.println(this.a);//20
System.out.println(a);//30

}

}

}

[Test]

package com.itheima.a04interclassdemo4;

public class Test {
public static void main(String[] args) {
//创建内部类的对象，并调用show()方法
Outer.Inner oi = new Outer().new Inner();
oi.show();

}
}

(运行结果截图)

内部类的内存图

（第一步）

（第二步）

总结

静态内部类

什么是静态内部类？

例如：

（源代码）

[Outer]

package com.itheima.a05interclassdemo5;

public class Outer {

//静态内部类
static class Inner{
public void show1(){
System.out.println("非静态方法被调用了");
}
public static void show2(){
System.out.println("静态方法被调用了");
}

}
}

[Test]

package com.itheima.a05interclassdemo5;

public class Test {
public static void main(String[] args) {

Outer.Inner oi = new Outer.Inner();
oi.show1();

Outer.Inner.show2();

}
}

(运行结果截图)

总结

局部内部类

什么是局部内部类？

例如：

（源代码）

[Outer]

package com.itheima.a06interclassdemo6;

public class Outer {
int b = 20;
public void show(){
int a = 10;
//局部内部类
class Inner{
String name;
int age;

public void method1(){
System.out.println(a);
System.out.println(b);
System.out.println("局部内部类中的method1方法");
}

public static void method2(){
System.out.println("局部内部类中的method2方法");
}

}
Inner i = new Inner();
System.out.println(i.name);
System.out.println(i.age);
i.method1();
Inner.method2();
}

}

[Test]

package com.itheima.a06interclassdemo6;

public class Test {
public static void main(String[] args) {

Outer o = new Outer();
o.show();

}
}

(运行结果截图)

匿名内部类

什么是匿名内部类？

注：上面图片中红框内的代码最后缺少一个 ;

例1:（接口-实现关系）

（分析）

(源代码)

[Swim](接口interface)

package com.itheima.a07interclassdemo7;

public interface Swim {
public abstract void swim();
}

[Test]

package com.itheima.a07interclassdemo7;

public class Test {
public static void main(String[] args) {

//编写匿名内部类的方法
new Swim(){
@Override
public void swim() {
System.out.println("重写swim方法");
}
};

}
}

例2：（类-继承关系）

（分析）

（源代码）

[Animal]

package com.itheima.a07interclassdemo7;

public abstract class Animal {
public abstract void eat();
}

[Test2]

package com.itheima.a07interclassdemo7;

public class Test2 {
public static void main(String[] args) {

new Animal(){
@Override
public void eat() {
System.out.println("重写eat方法");
}
};

}
}

例如：（其他）

（源代码）

[Swim]

package com.itheima.a07interclassdemo7;

public interface Swim {
public abstract void swim();
}

[Test3]

package com.itheima.a07interclassdemo7;

public class Test3 {
public static void main(String[] args) {

//整体我们可以理解为Swim接口的实现类对象
//接口多态
Swim s = new Swim() {

@Override
public void swim() {
System.out.println("重写swim方法");
}

};
//编译看左边，运行看右边
s.swim();

new Swim() {

@Override
public void swim() {
System.out.println("重写swim方法");
}

}.swim();

}
}

(运行结果截图)

总结