1.抽象类与抽象方法
注意：
抽象类不能实例化
抽线类中不一定有抽i像方法，有抽象方法的类一定是抽象类
可以有构造方法
抽象类的子类要么重写抽象类中的所有抽象方法，要么是抽象类
抽象类的作用：
抽取共性时，无法确定方法体，就把方法定义为抽象的。
强制让子类按照某种格式重写。
抽象方法所在的类，必须是抽象类
抽象类和抽象方法的格式？
public abstract 返回值类型 方法名 （参数列表）；
public abstract class 类名{}
抽象类在多态方面的继承：
// 抽象类和抽象方法需要被 abstract 关键字修饰
abstract class Shape {// 抽象类中的方法一般要求都是抽象方法，抽象方法没有方法体abstract void draw();
}
// 当一个普通类继承一个抽象类后，这个普通类必须重写抽象类中的方法
class Cycle extends Shape {@Overridevoid draw() { // 重写抽象类中的draw方法System.out.println("画一个圆圈");}
}public class Test4 {public static void main(String[] args) {//Shape shape = new Shape(); 抽象类虽然不能直接实例化// 但可以把一个普通类对象传给一个抽象类的引用呀，即父类引用指向子类对象Shape shape = new Cycle(); // 这称作：向上转型/*Cycle cycle = new Cycle();Shape shape = cycle // 这是向上转型的另一种写法*/shape.draw(); // 通过父类引用调用被子类重写的方法}
}2.接口
接口：就是一种规则
例：兔子不会游泳，而青蛙和狗类会，则不能放在父类里，则需要创建一个具有游泳功能的接口。
接口设计规则：
- 抽取派生类的共同属性和行为抽到超类中，
- 抽象类：如果子类方法都一样设计为普通方法，如果子类的行为不是有一致的就写成抽象方法
- 接口：抽取部分子类相同行为，抽取到接口中——多继承，多实现，接口是对单继承的扩展
接口的定义与使用：
//接口定义的关键字interface
//接口都需要有实现类
public interface userService {//接口中的所有定义都是抽象的 public abstractvoid add(String name);void delete(String name);void update(String name);void query(String name);
}
public interface timeService {void timer();
}
//类可以实现接口 implements
//实现了接口的类，就需要重写接口中的方法
//利用接口实现多继承
public class userServiceImpl implements userService,timeService{@Overridepublic void add(String name) {}@Overridepublic void delete(String name) {}@Overridepublic void update(String name) {}@Overridepublic void query(String name) {}@Overridepublic void timer() {}
}接口的换代升级：
适用于添加接口新功能
3.内部类
内部类表示的事物是外部类的一部分，内部类单独出现没有任何意义。
内部类的访问特点：
1.内部类可以直接访问外部类的成员，包括私有
2.外部类要访问内部类的成员，必须创建对象
什么时候用到内部类？
例：需要录入车的信息，那么发动机的品牌，颜色，型号就可以当一个内部类
下图中Engine为内部类
内部类主要分为：静态内部类，非静态内部类。（static静态修饰）
注意：非静态内部类里不能有静态方法，静态成员变量，静态初始化块。
main获取内部类的对象：
1.Car.Engine r=new Car().new.Engine();直接创建（格式：外部类名.内部类名 对象名=外部类对象.内部类对象）
2.外部类编写方法，对外部类提供内部对象（private）
非静态外部类访问内部类
public class jtai {private String prop="外部变量";private class InClass {private String prop = "内部变量";public void print() {String prop = "局部变量";System.out.println("外面 " + jtai.this.prop);System.out.println("内部 " + this.prop);System.out.println("局部 " + prop);}}
public void test() {InClass obj=new InClass();obj.print();
}public static void main(String[] args) {new jtai().test();}
}非静态内部类访问外部类
// 外部类
class OuterClass {private int outerField = 10;// 内部类class InnerClass {void accessOuter() {System.out.println("访问外部类的成员变量: outerField = " + outerField);System.out.println("调用外部类的方法:");outerMethod();}}// 外部类的方法void outerMethod() {System.out.println("这是外部类的方法");}// 外部类的入口方法public static void main(String[] args) {// 创建外部类的对象OuterClass outerObj = new OuterClass();// 创建内部类的对象OuterClass.InnerClass innerObj = outerObj.new InnerClass();// 调用内部类访问外部类的方法innerObj.accessOuter();}
}
静态内部类：只能访问外部类中的静态变量和静态方法，如果想要访问非静态的想要创建对象。
静态内部类访问外部类：
// 外部类
class OuterClass {private static int outerStaticField = 100;private int outerField = 10;// 静态内部类static class StaticInnerClass {void accessOuter() {// 访问外部类的静态成员变量System.out.println("访问外部类的静态成员变量: outerStaticField = " + OuterClass.outerStaticField);// 若要访问外部类的非静态成员变量，需要通过外部类的对象访问OuterClass outerObj = new OuterClass();System.out.println("访问外部类的非静态成员变量: outerField = " + outerObj.outerField);// 若要调用外部类的方法，也需要通过外部类的对象访问outerObj.outerMethod();}}// 外部类的方法void outerMethod() {System.out.println("这是外部类的方法");}// 外部类的入口方法public static void main(String[] args) {// 创建静态内部类的对象StaticInnerClass innerObj = new StaticInnerClass();// 调用内部类访问外部类的方法innerObj.accessOuter();}
}
外部类访问静态内部类
// 外部类
class OuterClass {private static int outerStaticField = 100;// 静态内部类static class StaticInnerClass {void innerMethod() {System.out.println("这是静态内部类的方法");}}// 外部类的方法void outerMethod() {System.out.println("这是外部类的方法");// 在外部类的方法中创建静态内部类的对象并调用其方法StaticInnerClass innerObj = new StaticInnerClass();innerObj.innerMethod();}// 外部类的入口方法public static void main(String[] args) {// 在外部类的静态方法中创建静态内部类的对象并调用其方法StaticInnerClass innerObj = new StaticInnerClass();innerObj.innerMethod();// 在外部类的静态方法中创建外部类的对象并调用其方法OuterClass outerObj = new OuterClass();outerObj.outerMethod();}
}
有没有发现一个现象即静态与非静态的相互访问都需要用到关键字new，因为静态会开辟空间，呢哇也是。
注意：使用静态内部类比使用非静态内部类简单很多，只要把外部类当成静态内部类的包空间即可。
