面向对象之四

---

1.抽象类

加了abstract就变成了抽象类抽象类中可以写普通的方法

特点：

1.不能new这个抽象类，只能靠子类去实现它；约束

2.抽象类中可以写普通的方法

3.抽象方法必须在抽象类中

抽象的抽象：约束

存在的意义：抽象出来~ 提高开发效率

//abstract  抽象类：本质上还是类。Java的类是单继承的，extends：单继承      （接口可以多继承）
public abstract class Action {
    //约束~有人帮我们实现~
    //abstract,抽象方法，只有方法名字，没有方法的实现！
    public abstract void doSomething();

}



//抽象类的所有方法，继承了它的子类，都必须要实现它的方法，除非它的之类也是abstract
public class A extends Action {
    @Override
    public void doSomething() {

    }
}

---

2.接口

1.接口只有方法的定义，通过interface来定义，定义完之后，子类要去实现它，通过implements关键字实现了接口之后，重写了里面的方法。

2.接口就相当于一个约束

接口中的方法：

//interface  定义的关键字  。接口都需要有实现类
public interface UserService {
    //接口中的所有定义的方法其实都是抽象的  public abstract
    public abstract void add(String name);//接口可以这样子写：返回值类型+方法名，括号里可以加个参数
    void delete(String name);
    void update(String name);
    void query(String name);
    
}





public interface TimeService {
    void timer();
}






//抽象类： extends 单继承
//类  可以实现接口 implements 借款
//要实现了接口的类，就需要重写接口中的方法
//多继承  利用接口实现多继承
public class UserServiceImpl implements UserService,TimeService{

    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void query(String name) {

    }

    @Override
    public void timer() {

    }
}

在接口中定义的属性都是常量（一般不这样操作）

修饰：public static final

作用：

1.约束

2.定义一些方法，让不同的人实现。

3.方法定义： public abstract

4.常量定义：public static final

5.接口不能被实例化，因为接口中没有构造方法

6.接口可以通过implements方法，实现多个接口

7.必须要重写接口中的方法```

---

3.内部类

1.成员内部类

• 在类的内部定义，与实例变量、实例方法同级别的类。。
• 外部类的一个实例部分，创建内部类对象时，必须依赖外部类对象。

2.局部内部类

• 定义在外部类方法中，作用范围和创建对象范围仅限于当前方法。

3.静态内部类

• 不依赖外部类对象，可直接创建或通过类名访问，可声明静态成员。
• 只能直接访问外部类的静态成员（实例成员需实例化外部类对象）。

4.匿名内部类

• 没有类名的局部内部类（一切特征都与局部内部类相同）。

//外部类
public class Outer {
    //实例变量
    private String name = "hjx";
    private int age = 18;

    //内部类
    class Inner{
        private String address = "北京";
        private String name = "xjh";
        //方法
        public void show(){
            //内部类属性和外部类的属性相同时，打印外部类的属性，用Outer.this
            System.out.println(Outer.this.name);  //hjx
            //打印内部类的属性
            System.out.println(this.name);   //xjh
        }
    }

}







public class Application {
    public static void main(String[] args) {
        Outer outer = new Outer();
        Outer.Inner inner = outer.new Inner();
        inner.show();
    }
}

//外部类
public class Outer {
    //实例变量
    private String name = "hjx";
    private int age = 18;
    
    //静态内部类，和外部类相同
    static class Inner1{
        private String address = "上海";
        //静态成员
        private static int count = 100;
        public void show(){
            //调用外部类的属性
            //1.先创建外部类对象
            Outer outer = new Outer();
            //2.调用外部类的属性
            System.out.println(outer.name);  //hjx
            System.out.println(outer.age);  //18
            //调用静态内部类的属性和方法
            System.out.println(address);  //上海
            //调用态内部类的的静态属性
            System.out.println(Inner1.count); //100     静态成员通过(类名.变量)访问

        }
    }

}






public class Application {
    public static void main(String[] args) {
        //直接创建静态内部类对象
        Outer.Inner1 inner1 = new Outer.Inner1();
        //调用方法
        inner1.show();

    }
}

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);  //10
        }


        //局部内部类
        public void method(){
            class Inner1{

            }
        }



    }
    //一个Java类中可以有多个class类，但是只能有一个 public class
    class A{

    }




}







public class Application {
    public static void main(String[] args) {
        //外部类通过new关键字来实现
        Outer outer = new Outer();

        //通过外部类来实例化内部类
        Outer.Inner inner = outer.new Inner();
        inner.in();
        inner.getId();

    }
}

public class Test {
    public static void main(String[] args) {
        Apple apple = new Apple();
         /*new一个Apple，这个Apple的名字是apple，
           实例化了这个对象，并且把这个对象赋值给了apple。对象名：apple
          */

        //匿名内部类：没有名字初始化类，不用将实例保存到变量中
        new Apple().eat();  //匿名对象的使用
        
        new UserService(){  //这个方法会返回一个userService对象，但是它没有名字。
                            //这个类就是实现了接口的类，这个类也没有名字
            //要重写里面的方法
            @Override
            public void hello() {

            }
        };
        
    }
}
class Apple{
    public void eat(){
        System.out.println("1");

    }
}

//接口
interface UserService{
    void hello();
}