java大数据学习第十天---接口 面向接口开发 内部类

接口

1. 接口的特点:

   • 使用interface关键字定义接口

     interface 接口名{}
     

   • 使用implements关键字建立接口实现类与接口的实现关系

     接口是父级，接口实现类是子级

     class 实现类 implements 父级接口 {}
     

   • 接口实现类需要实现接口的所有抽象方法,才能变成一个普通子类

   • 接口不可以实例化/创建对象

   • 接口没有构造函数

     实现类使用的super();是父类的无参构造

     没有明确指定父类时,super();代表的是才是Object的无参构造

   • 接口中都是静态常量;没有成员变量,因为会默认拼接public static final

   • 接口不是类!!

   • 接口都是抽象方法,默认拼接public abstract

   • 接口是用来定制规则的:有哪些功能 方法有参数吗 有返回值吗

     具体实现交给接口的实现类来完成

2. 类与接口的关系

   1> 类与类的关系

   • 继承关系 只支持单继承

     比如A是父类,B是子类,B具备A的所有功能

     如果B对A的功能不满意 可以重写(两同 两小 一大)

   2> 类与接口的关系

   • 实现关系 可以单实现 也可以 多实现

   • class A implements B,C{}

     ​ A 是实现类 B C 是接口, A需要实现B C接口的所有抽象方法 否则A就是一个抽象类

   3> 接口与接口的关系

   • 继承关系 可以 单继承 也可以 多继承

   • interface A extends B,C{}

     A B C 都是接口, A 是子接口 , 具有 B C 父接口的所有功能(抽象方法)

     class X implements A{}

     X 实现类需要实现A接口,以及A接口继承自B C 接口的所有抽象方法,否则就是抽象类

   • class O extends A implements B C {} 先继承后实现

     其中O是实现类,也是A的子类,同时拥有A的所有功能 并且需要实现B C 的所有功能

   4> 接口与抽象类比较

   • 接口 是一种用 interface 定义的类型

     抽象类 是一种用class定义的类型

   • 接口中的方法都是抽象方法

     抽象类中方法不做限制

   • 接口当中都是静态常量

     抽象类中可以写普通的成员变量

   • 接口中没有构造方法,不可以实例化

     抽象类中有构造方法 ,但是也不可以实例化

   • 接口是先天设计的结果,

     抽象类是后天重构的结果

   • 接口可以多继承

     抽象类只能单继承

内部类

1. 概念

   A类中又定义了B类，B类就是内部类,B类可以当做A类的一个成员看待

2. 内部类对象创建格式:

   		外部类名.内部类名 对象名 = 外部类对象.内部类对象
   比如:		Outer.Inner.oi = new Outer().new Inner();
   

3. 分类:

   根据内部类位置的不同分为: 成员内部类 局部内部类

4. 特点

   • 内部类可以直接使用外部类的所有资源,包括私有资源

     外部类如果想要调用内部类资源,需要现创建内部类对象,通过内部类对象调用内部类资源

   • 如果成员内部类被private修饰,无法直接在外界创建成员内部类对象

     可以通过创建外部类的对象,间接调用成员内部类资源

     public class TestInner2 {
         public static void main(String[] args) {
             //调用内部类eat()方法
             //Outer2.Inner2 oi2 = new Outer2().new Inner2();
             //oi2.eat();
             /*如果内部类被private修饰 无法直接在外界创建内部类对象
             * 我们可以创建外部类的对象,间接访问内部类的资源*/
             new Outer2().getInner2Eat();
         }
     }
     //1.创建外部类outer2
     class Outer2{
         //6.对外提供公共的方法
         public void getInner2Eat(){
             //创建内部类对象  调用内部类功能
             Inner2 in = new Inner2();//同类中 可以调用私有资源
             in.eat();
         }
         //2.创建内部类 Inner2
         //5.成员内部类被private修饰 私有化的资源无法被外界访问
         private class Inner2{
             //3.创建内部类的普通方法
             public void eat(){
                 System.out.println("内部类...eat()");
             }
         }
     
     

   • 成员内部类被static修饰

     • 当内部类被static修饰时,可以称为静态内部类,

       静态内部类不需要先创建外部类对象,而是通过外部类的类名找到内部类,再创建内部类对象

       格式: 外部类名.内部类名 对象名 = new 外部类名.内部类名 ();

       比如:		Outer3.Inner3 oi = new Outer3.Inner3();
                oi.show();
       

     • 如果静态内部类中有静态资源,可以不创建一个对象,直接通过下边格式调用静态资源

       格式: 外部类名.内部类名.静态资源名

        Outer3.Inner3.show2();
       

   • 局部内部类

     • 位置: 方法里

     • 如何使用局部内部类的资源呢?

       答: 直接调用外部类的方法是无法触发局部内部类功能的

       ​ 需要在外部类中创建内部类的对象并且进行调用,才能触发内部类功能

       ​ 并且创建内部类对象时必须在方法里而且在内部类结束后在内部类后边创建内部类对象

       public class TestInner4 {
           public static void main(String[] args) {
               /*如何使用局部内部类的资源呢?
               * 注意:直接调用外部类的show()方法是无法触发内部类功能的
               * 需要在外部类中创建内部类的对象并且进行调用,才能触发内部类功能*/
               //5.创建外部类对象调用show()
               new Outer4().show();
       
           }
       }
       //1.创建外部类
       class Outer4{
           //2.创建外部类成员方法
           public void show(){
               System.out.println("我是外部类的show()");
               //3.创建局部内部类
               /*局部内部类的位置在方法里*/
               class Inner4{
                   //4.创建局部内部类的资源
                   String name;
                   int age;
                   public void eat(){
                       System.out.println("我是局部内部类的eat()");
                   }
               }
               //6.在show()里,内部类结束后 创建内部类对象---必须在内部类之后
               Inner4 in = new Inner4();
               in.eat();
               System.out.println(in.age);
               System.out.println(in.name);
           }
       }
       

   • 匿名内部类

     • 匿名内部类没有名字 通常与匿名对象结合在一起使用

     • 匿名对象只能使用一次 一次只能调用一个功能

     • 匿名内部类只是充当了实现类的角色,去实现未实现的方法 只是没有名字而已

       如果想要多次使用实现后的功能 还要创建之前的普通对象

     public class TestInner5 {
         public static void main(String[] args) {
             //3.创建了接口1对应的匿名对象 实现了接口中的方法 调用了实现方法 -----实现的方法只能用一次
      new Inter1() {//这个大括号里的内容就是匿名内部类
                 @Override
                 public void save() {
                     System.out.println("实现保存方法");
                 }
     
                 @Override
                 public void get() {
     
                 }
             }.save();
     
     
     //5.
      new Inter2() {
             @Override
             public void drink() {
                 System.out.println("一人我饮酒醉");
             }
         }.play();
     
     
      //7
             new Inter3().study();
     
         }
     
     }
     //1.创建接口
     interface Inter1{
         //2.定义接口中的抽象方法
         void save();
         void get();
     
     }
     
     //4.创建抽象类
     abstract class Inter2{
         public void play(){
             System.out.println("玩代码");
         }
     
         abstract public void drink();
     }
     
     //6. 创建普通类
     class Inter3{
         public void study(){
             System.out.println("什么都无法阻挡我学习赚钱的决心");
         }
         public void powerUp(){
             System.out.println("我们会越来越强的!!!!!");
         }
     }