【黑马程序员】抽象类、接口和内部类

:抽象类
 (1)把多个共性的东西提取到一个类中，这是继承的做法。
    但是呢，这多个共性的东西，在有些时候，方法声明一样，但是方法体。
    也就是说，方法声明一样，但是每个具体的对象在具体实现的时候内容不一样。
    所以，我们在定义这些共性的方法的时候，就不能给出具体的方法体。
    而一个没有具体的方法体的方法是抽象的方法。
    在一个类中如果有抽象方法，该类必须定义为抽象类。
 (2)抽象类的特点
  A:抽象类和抽象方法必须用关键字abstract修饰
  B:抽象类中不一定有抽象方法,但是有抽象方法的类一定是抽象类
  C:抽象类不能实例化
  D:抽象类的子类
   a:是一个抽象类。
   b:是一个具体类。这个类必须重写抽象类中的所有抽象方法。
 (3)抽象类的成员特点：
  A:成员变量
   有变量，有常量
  B:构造方法
   有构造方法
  C:成员方法
   有抽象，有非抽象
 (4)抽象类的练习
  A:猫狗案例练习
  B:老师案例练习
  C:学生案例练习
  D:员工案例练习
 (5)抽象类的几个小问题
  A:抽象类有构造方法，不能实例化，那么构造方法有什么用?
   用于子类访问父类数据的初始化
  B:一个类如果没有抽象方法,却定义为了抽象类，有什么用?
   为了不让创建对象
  C:abstract不能和哪些关键字共存
   a:final 冲突
   b:private 冲突
   c:static 无意义

4

/*定义抽象类 格式 :abstract class 类名{} 举例 :抽象类中的 方法抽象方法  abstract void eat();没有方法体,没有{},以; 结尾.  非抽象方法 void sleep(){syso ....}抽象类子类:1.非抽象类,但是必须重写父类的抽象方法2.抽象类,无须管抽象方法,但是子类不能new了抽象类中,有构造方法,但是有不能new,那么构造方法干嘛的呢? 给子类用的!!!抽象类,一样可以使用多态来创建子类对象 .总结: 一般来说,会把父类定义为抽象的类.测试的时候,可以通过多态,来实现子类功能. 抽象类接口成员变量变量,常量构造方法有成员方法抽象,非抽象*/class AnimalTest{public static void main(String[] args){//Cat c  = new Cat();  // 抽象的,无法创建对象//c.eat();//Animal a = new Animal();//多态Animal a  = new Cat();a.eat();System.out.println(a.num);System.out.println(a.num2);}}abstract class Animal{int num =10;final int num2 = 20;Animal(){} //eat public abstract void eat();//sleeppublic void sleep(){System.out.println("合眼就睡");}} class Cat extends Animal{Cat(){super();}//eatpublic  void eat(){System.out.println("用爪子抓鱼,用舌头添鱼肉,不吐刺儿..喵喵儿~~");}//public abstract void eat();//sleeppublic void sleep(){System.out.println("合眼就睡,白天,想睡就睡");}}

/*接口:引用数据类型 interface  interface 接口名{}本质:它是一种规则.定义接口,就是定义了规则.实现接口,相当于扩展了功能. 实现接口: implements举例:  Cat implements Train 注意: 1. 接口中的方法,是抽象的.2. 接口的子类,必须重写接口的中的所有的抽象方法 */class MiaoXingRenTest{public static void main(String[] args){System.out.println();MiaoXingRen  mxr = new MiaoXingRen();mxr.eat();mxr.count();}}interface Train{//public void count(){//System.out.println("数数");//}public abstract void count();public abstract void sing(); }class Animal  {public void eat(){System.out.println("吃东西");}}class Cat extends Animal{public void eat(){System.out.println("吃鱼");}}/*喵星人,会数数   */class MiaoXingRen extends Cat implements Train {public void count(){System.out.println("数数");}public void sing(){System.out.println("按我的唱法来");}}

/*抽象类的成员特点：成员变量：既可以是变量，也可以是常量。构造方法：有。用于子类访问父类数据的初始化。成员方法：既可以是抽象的，也可以是非抽象的。抽象类的成员方法特性：A:抽象方法 强制要求子类做的事情。B:非抽象方法 子类继承的事情，提高代码复用性。*/abstract class Animal {public int num = 10;public final int num2 = 20;public Animal() {}public Animal(String name,int age){}public abstract void show();public void method() {System.out.println("method");}}class Dog extends Animal {public void show() {System.out.println("show Dog");}}class AbstractDemo2 {public static void main(String[] args) {//创建对象Animal a = new Dog();a.num = 100;System.out.println(a.num);//a.num2 = 200;System.out.println(a.num2);System.out.println("--------------");a.show();a.method();}}

内部类(理解)(1)把类定义在另一个类的内部，该类就被称为内部类。举例：把类B定义在类A中，类B就被称为内部类。(2)内部类的访问规则A:可以直接访问外部类的成员，包括私有B:外部类要想访问内部类成员，必须创建对象(3)内部类的分类A:成员内部类B:局部内部类(4)成员内部类A:private 为了数据的安全性B:static 为了访问的方便性成员内部类不是静态的：外部类名.内部类名 对象名 = new 外部类名.new 内部类名();成员内部类是静态的：外部类名.内部类名 对象名 = new 外部类名.内部类名();(5)成员内部类的面试题(填空)30,20,10class Outer {public int num = 10;class Inner {public int num = 20;public viod show() {int num  = 30;System.out.println(num);System.out.println(this.num);System.out.println(Outer.this.num);}}}(6)局部内部类A:局部内部类访问局部变量必须加final修饰。B:为什么呢?因为局部变量使用完毕就消失，而堆内存的数据并不会立即消失。所以，堆内存还是用该变量，而改变量已经没有了。为了让该值还存在，就加final修饰。通过反编译工具我们看到了，加入final后，堆内存直接存储的是值，而不是变量名。(7)匿名内部类(掌握)A:是局部内部类的简化形式B:前提存在一个类或者接口C:格式:new 类名或者接口名() {重写方法;}D:本质：其实是继承该类或者实现接口的子类匿名对象(8)匿名内部类在开发中的使用我们在开发的时候，会看到抽象类，或者接口作为参数。而这个时候，我们知道实际需要的是一个子类对象。如果该方法仅仅调用一次，我们就可以使用匿名内部类的格式简化。interface Person {public abstract void study();}class PersonDemo {public void method(Person p) {p.study();}}class PersonTest {public static void main(String[] args) {PersonDemo pd = new PersonDemo();pd.method(new Person() {public void study() {System.out.println("好好学习，天天向上");}});}}(9)匿名内部类的面试题(补齐代码)interface Inter {void show();}class Outer {//补齐代码public static Inter method() {return new Inter() {public void show() {System.out.println("HelloWorld");}};}}class OuterDemo {public static void main(String[] args) {Outer.method().show(); //"HelloWorld"}}

:接口
 (1)回顾猫狗案例，它们仅仅提供一些基本功能。
    比如：猫钻火圈，狗跳高等功能，不是动物本身就具备的，
    是在后面的培养中训练出来的，这种额外的功能，java提供了接口表示。
 (2)接口的特点：
  A:接口用关键字interface修饰
   interface 接口名 {}
  B:类实现接口用implements修饰
   class 类名 implements 接口名 {}
  C:接口不能实例化
  D:接口的实现类
   a:是一个抽象类。
   b:是一个具体类，这个类必须重写接口中的所有抽象方法。
 (3)接口的成员特点：
  A:成员变量
   只能是常量
   默认修饰符：public static final
  B:构造方法
   没有构造方法
  C:成员方法
   只能是抽象的
   默认修饰符：public abstract
 (4)类与类,类与接口,接口与接口
  A:类与类
   继承关系，只能单继承，可以多层继承
  B:类与接口
   实现关系，可以单实现，也可以多实现。
   还可以在继承一个类的同时，实现多个接口
  C:接口与接口
   继承关系，可以单继承，也可以多继承
 (5)抽象类和接口的区别(自己补齐)?
  A:成员区别
   抽象类：
   接口：
  B:关系区别:
   类与类：
   类与接口：
   接口与接口：
  C:设计理念不同
   抽象类：is a，抽象类中定义的是共性功能。
   接口：like a，接口中定义的是扩展功能。
 (6)练习：
  A:猫狗案例，加入跳高功能
  B:老师和学生案例，加入抽烟功能0