java面向对象：抽象类、接口以及内部类

抽象类

abstract修饰符可以用来修饰方法也可以用来修饰类，如果修饰方法，那么这个方法就是抽象方法；如果修饰类，那么该类即使抽象类
抽象类中可以没有抽象方法，但是有抽象方法的类一定是抽象类
抽象类，不能使用new关键字来创建对象，他是用来让子类继承的
抽象方法，只有方法的声明，没有方法的实现，他是用来让子类实现的
子类继承抽象类，那么必须要实现抽象类中的所有抽象方法，否则该子类也要声明为抽象类

package com.oop.demo8;
//一个类继承了抽象类 要么实现抽象类里面的所有方法 要么把自己也变成抽象类
public class A extends Action {
    @Override
    public void hello() {

    }
}

package com.oop.demo8;

/**
 * 1.抽象类不能够被实例化 就是不能new抽象类，只能靠他的子类去实现它
 * 2.抽象类中可以有普通方法
 * 3.抽象方法必须是在抽象类中
 *
 * 思考：抽象类中存在构造方法吗？
 * 存在 因为子类继承父类最终一定会调用到父类构造
 */
 public abstract class Action {
     //加了abstract关键字为抽象方法
     public abstract void hello();
}

接口

普通类：只有普通方法，只有具体的实现
抽象类：有具体实现和规范(抽象方法)都有
接口：只有规范！！
接口就是规范，定义的是一组规则，体现了现实世界中“如果你是……则必须能……”。如果你是天使，则必须能飞，如果你是汽车，则必须能跑。……
接口的本质是契约，就像我们人间的法律一样，制定好后大家都需要遵守
OO的精髓，是对象的抽象，最能体现到这一点的就是接口。为什么我们讨论设计模式都只针对具备了抽象能力的语言（比如java、c++、c#等），就是因为设计模式所研究的，实际上就是如何合理的去抽象

package com.oop.demo9;

//class为一个类   interface为一个接口
public interface UserService {
    //接口中的所有方法都是抽象方法
    //所有的方法前面 都有默认的修饰符 public abstract
    //接口中的所有变量都是静态常量  都有默认的修饰符 public static final
public static final String NAME="张三";
    void add();
    void del();
   public abstract void update();
    void query();
}

package com.oop.demo9;

/**
 * 接口的注意点：
 *  1.约束
 *  2.所有的抽象方法前面都有默认的修饰符 public abstract 默认可以不写
 *  3.接口中所有的变量都为静态常量 前面也有默认的修饰符 public static final 默认可以不写
 *  4.接口中，没有构造方法，不能被实例化
 *  5.implements可以实现多个接口
 *  6.一个类实现了接口，必须实现该接口中的所有抽象方法
 */
public interface ProdService {
    void hello();
}

package com.oop.demo9;

//如果一个类实现了该接口 那这个类必须实现接口中的所有抽象方法
//java中只有单继承 但是可以实现多个接口，用，隔开
public class UserServiceImpl implements UserService,ProdService {
    @Override
    public void add() {

    }

    @Override
    public void del() {

    }

    @Override
    public void update() {

    }

    @Override
    public void query() {

    }

    @Override
    public void hello() {

    }
}

内部类

内部类就是在一个类的内部在定义类，比如A类中定义一个B类，那么B类相对A来说成为内部类，而A类相对于B类来说就是外部类了

成员内部类

public class Outer {
    private int id=10;
    public void out(){
        System.out.println("这是外部类方法");
    }
    //成员内部类
    public class Inner{
        public void in(){
            System.out.println("这是内部类方法");
        }
        public void getId(){
            //可以调用外部类的私有属性
            System.out.println(id);
        }
    }
}

package com.oop.demo10;

public class Test {
    public static void main(String[] args) {
        Outer outer = new Outer();
        //通过外部类来实例化内部类
        Outer.Inner inner = outer.new Inner();
        inner.in();
        inner.getId();
    }
}

静态内部类

package com.oop.demo10;
public class Outer {
    private int id=10;
    public void out(){
        System.out.println("这是外部类方法");
    }
    //静态内部类
    public static class Inner{
        public void in(){
            System.out.println("这是静态内部类方法");
        }
    }
}

局部内部类

package com.oop.demo10;
public class Outer {
  public void method(){
      //局部内部类
      class Inner{
          public void in(){
              System.out.println("这是局部内部类");
          }
      }
  }
}
//一个java类中只能有一个public class
//但是可以有多个class
class A{
    public static void main(String[] args) {

    }
}

匿名内部类

package com.oop.demo10;

public class Test {
    public static void main(String[] args) {
        //没有名字的初始化类,不用将实例保存到变量中
        new Cat().eat();

      new UserService(){
            @Override
            public void add() {

            }
        };
    }
}
class Cat{
    public void eat(){
        System.out.println("吃吃吃");
    }
}
interface UserService{
    void add();
}

posted @ 2021-09-09 08:39 ᦔⅈ晚风（扬帆起航）阅读(38) 评论(0) 收藏举报

刷新页面返回顶部

ᦔⅈ晚风（扬帆起航）

java面向对象：抽象类、接口以及内部类

抽象类

接口

内部类

公告