面向对象编程外围（2）
一.抽象类
1.概述
一个没有办法体的办法应该被定义为形象办法，而类中如果有形象办法，则类为抽象类。
public abstratc class Animal{ public abstract void eat(){ }} 2.抽象类的特点
1)抽象类和形象办法必须用abstract润饰。
2）抽象类中不肯定有形象办法，但形象办法肯定在抽象类中。
3）抽象类不能实例化，只能通过子类实例化（相似向上转型）
public abstratc class Animal{ public abstract void eat(){ }} public class Cat extends Animal{ @Override public void eat(){ System.out.println("猫吃鱼"); }}public class AnimalDemo{ public static void main(String[] args){ Animal a = new Cat(); a.eat(); }}4)抽象类的子类要么是抽象类，要么重写抽象类中所有的办法
public abstratc class Animal{ public abstract void eat(){ } public abstract void sleep(){ } } public class Cat extends Animal{ @Override public void eat(){ System.out.println("猫吃鱼"); } public void sleep(){ System.out.println("猫睡觉"); }}或：public class abstract Cat extends Animal{ }5)抽象类的构造方法和成员办法
有构造方法，但不能实例化，用于子类拜访父类数据的初始化。而成员办法有形象办法，次要用于规定子类办法必须实现的动作，也有非形象办法，用于进步代码复用性。
二.接口
1.概述
接口是一种公共的标准规范，只有符合标准，大家能够通用。Java的接口更多体现在对行为的形象。
2.接口的特点
1）接口用关键字interface润饰
2）类实现接口用implements示意,同时接口中的办法都为形象办法(void show() = public abstract void show())
public class 类名 implements 接口名 {}3)接口间接不能实现化，办法与多态类似
public interface Eat{ public abstract void eat(){ }} public class Cat implements Eat{ @Override public void eat(){ System.out.println("猫吃鱼"); }}public class EatDemo{ public static void main(String[] args){ Animal a = new Cat(); a.eat(); }}4）接口的实现类要么是抽象类，要么重写接口中所有的办法
public interface Eat{ public abstract void eat(){ } public abstract void sleep(){ } } public class Cat implements Eat{ @Override public void eat(){ System.out.println("猫吃鱼"); } public void sleep(){ System.out.println("猫睡觉"); }}或：public class abstract Cat implements Eat{ }3.接口的成员变量和构造方法
成员变量只能为常量（默认修饰符：public static final)，没有构造方法。
4.类和接口的关系
public class InterImpl extends Object implements Inter1,Inter2,Inter3{}public interface Inter3 extends Inter1,Inter2{}5.抽象类和接口的区别
public interface Alarm{ //接口中默认为public abstract void alarm() void alarm();}public abstract class door{ public abstract void open(); public abstract void close();}public class AlarmDoor extends door implements Alarm{ public void alarm(){ //... } public void close(){ //... } public void open(){ //... }}在开发中，抽象类更多是对事物的形象，接口是对行为的形象。6.抽象类和接口作为形参和返回值
1）抽象类：
public interface Jumping{ void jump(){ }} public class Cat implements Jumping{ @Override public void jump(){ System.out.println("猫跳高"); }}public class JumpingOperator{ //办法的形参是接口名，其实须要的是该接口的实现类对象 public void useJumping(Jumping j){ j.jump(); } //办法的返回值是接口名，其实返回的是该接口的实现类对象 public Jumping getJumping(){ Jumping j = new Cat(); return j;}public class JumpingDemo{ public static void main(String[] args){ JumpingOperator jo = new JumpingOperator(); Jumping j = new Cat(); //JumpingOperator中相当于Jumping jo = new Cat(); jo.useJumping(j); //相当于Jumping j2 = new Cat() Jumping j2 = ao.getJumping(); a2.jump(); }}2）接口：
public abstract class Animal{ public abstract void eat(){ }} public class Cat extends Animal{ @Override public void eat(){ System.out.println("猫吃鱼"); }}public class AnimalOperator{ //办法的形参是抽象类名，其实须要的是该抽象类的子类对象 public class useAnimal(Animal a){ a.eat(); } //办法的返回值是抽象类名，其实返回的是该抽象类的子类对象 public Animal getAnimal(){ Animal a = new Cat(); return a; }public class AnimalDemo{ public static void main(String[] args){ AnimalOperator ao = new AnimalOperator(); Animal a = new Cat(); //AnimalOperator中相当于Animal a = new Cat(); ao.useAnimal(a); //相当于Animal a2 = new Cat() Animal a2 = ao.getAnimal(); a2.eat(); }}三.外部类
1.概述
在一个类中定义一个类，例如在类A中定义类B，B就是外部类
public class Outer{ public class Inner{ }}2.外部类的拜访特点（仅限于外部类和外部类，不波及外部类以外的类）
1）外部类能够间接拜访外部类的成员，包含公有成员
2）外部类要拜访外部类的成员，必须创建对象
public class Outer{ private int num = 19; public class Inner{ public void show(){ System.out.println(num); } } public void method(){ Inner i = new Inner(); i.show(); }}3)外部类以外的类想拜访外部类的对象的对象创立形式
public class Outer{ private int num = 19; public class Inner{ public void show(){ System.out.println(num); } } public void method(){ Inner i = new Inner(); i.show(); }}public class InnerDemo{ public static void main(String[] args){ //创立外部类对象 Outer.Inner oi = new Outer().new Innre(); oi.show(); }}3.部分外部类
部分外部类在办法里定义的类，外界无奈间接应用，须要在办法外部创建对象应用，该类能够间接拜访外部类的成员，也能够拜访办法内的局部变量
public class Outer{ private int num = 10; public void method(){ class Inner{ public void show(){ System.out.println(num); } } Inner i = new Inner(); i.show(); }} public class OuterDemo{ public static void main(String[] args){ Outer o = new Outer(); o.method(); }}4.匿名外部类
前提：存在一个类或接口，而后在办法中创立
格局：
new 类名或者接口名（）{ 重写办法；}new Inter(){ public void show(){ }}实质是一个继承了该类或者实现了该接口的子类匿名对象具体实现：
public class Outer{ public void method() { //new Inter仅仅是一个对象，在前面加上.show()才是办法的调用 Inter i = new Inter() { @Override public void show() { System.out.println("匿名外部类"); } } i.show(); }}public interface Inter{ void show();}public class OuterDemo{ public static void main(String[] args){ Outer o = new Outer(); o.method(); }}