接口，内部类

合集 - 学习Java狂神(17)

1.JDK,JRE,JVM，helloworld2023-06-112.硬件，软件，Dos命令笔记2023-06-103.基本语法12023-06-134.基础语法2运算符2023-06-185.输入，选择，while循环2023-06-226.for循环2023-06-267.java方法2023-06-268.递归，计算器2023-06-269.数组2023-06-2810.面向对象,方法复习2023-06-2911. 对象2023-06-3012.封装，重写2023-07-0213.多态2023-07-0214.static总结,抽象2023-07-05

15.接口，内部类2023-07-06

16.异常2023-07-0617.javaSE总结2023-07-07

收起

接口

接口

1. 普通类:只有具体实现
2. 抽象类:具体实现和规范(抽象方法)都有!
3. 接口:只有规范!自己无法写方法_{专业的约束!约束和实现分离:面向接口编程}
4. 接口就是规范，定义的是一组规则，体现了现实世界中“如果你是.….则必须能..”的思想。如果你是天使，则必须能飞。如果你是汽车，则必须能跑。如果你好人，则必须干掉坏人;如果你是坏人,
   则必须欺负好人。
5. 接口的本质是契约，就像我们人间的法律一样。制定好后大家都遵守。
6. OO的精髓，是对对象的抽象，最能体现这一点的就是接口。为什么我们讨论设计模式都只针对具备了抽象能力的语言（比如c++、java、c#等)，就是因为设计模式所研究的，实际上就是如何合理的去抽象。

• 声明类的关键字是class,声明接口的关键字是interface

---

作用:

1. 约束

2. 定义一些方法，让不同的人实现~10--->1

3. public abstract

4. public static final

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

6. implements可以实现多个接口

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

package com.oop.demo09;
//interface 定义的关键字,接口都需要有实现类
//抽象的思维  架构师
public interface UserService {
    //接口中所有的定义都是抽象的 public abstract是默认的
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);

    //属性为常量 public static final
    int age =99;
}
============
    package com.oop.demo09;

public interface TimeService {
    void timer();
}
===========
    package com.oop.demo09;
//抽象类：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() {

    }
}

---

内部类

• 内部类就是在一个类的内部在定义一个类，比如，A类中定义一个B类，那么B类相对A类来说就称为内部类，而A类相对B类来说就是外部类了。
• 1.成员内部类
• 2.静态内部类
• 3.局部内部类
• 4.匿名内部类

package com.oop.demo10;

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);
       }
    }
}
//一个Java类中可以有多个class类，但是只能有一个public class
class A{
    public static void main(String[] args) {

    }
        }
==============
 package com.oop.demo10;

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

        }
    }

}
===========
    package com.oop.demo10;

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

            }
        };
    }
}
class Apple{
    public void eat(){
        System.out.println("11");
    }
}
interface UserServise{
    void hello();
}
=============
    package com.oop;


import com.oop.demo10.Outer;

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