标签：java String void System 面向对象 println public out

面向过程&面向对象

• 面向过程思想

  • 步骤清晰简单，第一步做什么，第二步做什么…...
  • 面对过程适合处理一些较为简单的问题。

• 面向对象思想

  • 物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索。
  • 面向对象适合处理复杂的问题，适合处理需要多人协作的问题!

• 对于描述复杂的事物，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是，具体到微观操作，仍然需要面向过程的思路去处理。

什么是面向对象

• 面向对象编程(Object-Oriented Programming ，OOP)

• 面向对象编程的本质就是：以类的方式组织代码，以对象的方式组织(封装)数据。

• 核心思想：抽象。

• 三大特性:

  • 封装
  • 继承
  • 多态

• 从认识论角度考虑是先有对象后有类。对象，是具体的事物。类,是抽象的，是对对象的抽象。

• 从代码运行角度考虑是先有类后有对象。类是对象的模板。

回顾方法及加深

方法的定义

• 修饰符
• 返回类型
• break和return的区别：break，跳出switch，结束循环；return，结束方法，返回结果。
• 方法名 ： 注意规范，见名知意
• 参数列表： (参数类型，参数名) 不定项参数（…）
• 异常抛出

代码：

import java.io.IOException;

//Demo类
public class Demo {

  //main方法
  public static void main(String[] args) {

  }

  /*
  修饰符 返回值类型 方法名(参数类型 参数名){
     ...
     //方法体;
     ...
     return 返回值;
   }
   */
  public String sayHello() {
      return "hello,world";
  }

  //返回值为空的方法
  public void print() {
      return;
  }

  public int max(int a, int b) {
      return a > b ? a : b; //三元运算符
  }

  //带异常抛出的方法
  public void readFile(String file) throws IOException {

  }
}

方法的调用

• 静态方法
• 非静态方法
• 形参和实参
• 值传递和引用传递
• this关键字：表示当前类的对象

静态方法和非静态方法代码：

import com.mlt.oop.demo.Student;

public class Demo {
    public static void main(String[] args) {

        //调用静态方法
        Student.sayHello();

        //调用非静态方法
        //实例化Student类：对象类型 对象名 = 对象值
        Student student = new Student();
        student.say();

    }
}

//学生类
public class Student {
    //非静态方法：类实例化之后才存在
    //非静态方法中，可以直接调用同一个类中的其他非静态方法和静态方法
    public void say(){
        System.out.println("学生说话了");
        sayHello();
    }

    //静态方法：和类一起加载的
    //静态方法中，可以直接调用其他静态方法，但不可以直接调用非静态方法
    public static void sayHello(){
        System.out.println("Hello");
    }
}

形参和实参代码：

public class Demo {
    public static void main(String[] args) {
        //实际参数和形式参数的类型要对应
        int add = Demo.add(1, 2);
        System.out.println(add);
    }

    public static int add(int a, int b) {
        return a + b;
    }
}

值传递和引用传递代码：

//值传递
public class Demo {
    public static void main(String[] args) {
        int a = 1;
        System.out.println(a); //输出1
        change(a);
        System.out.println(a); //输出1
    }

    //返回值为空
    public static void change(int a) {
        a = 10;
    }
}

//引用传递：当一个对象作为参数被传递给方法时，实际上传递的是对象的引用（地址），而不是对象本身的值。
//引用传递本质还是值传递，但是地址值传递。
public class Demo {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person.name); //输出null
        change(person);
        System.out.println(person.name); //输出麻辣烫
    }

    public static void change(Person person) {
        //person是一个对象：指向的是一个具体的地址，可以改变属性
        person.name = "麻辣烫";
    }
}

//一个类文件里可以有多个class，但只能有一个public class（这个public class的名称必须完全匹配该文件的名称，包括大小写）。
//定义了一个Person类，有一个属性：name
class Person {
    String name;
}

类与对象

• 类是一种抽象的数据类型，它是对某一类事物整体描述/定义,但是并不能代表某一个具体的事物。

  • 动物、植物、手机、电脑…...
  • Person类、Pet类、Car类等，这些类都是用来描述/定义某一类具体的事物应该具备的特点和行为

• 对象是抽象概念的具体实例

  • 张三就是人的一个具体实例，张三家里的旺财就是狗的一个具体实例。
  • 能够体现出特点，展现出功能的是具体的实例，而不是一个抽象的概念。

创建和初始化对象

• 使用new关键字创建对象

• 使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用。

• 类中的构造器也称为构造方法，是在进行创建对象的时候必须调用的。并且构造器有以下两个特点：

  • 必须和类的名字相同
  • 必须没有返回类型，也不能写void

• 构造器必须要掌握

代码：

//学生类
public class Student {
    //属性：字段field 成员变量
    String name; //默认null
    int age; //默认0

    //方法
    public void study() {
        System.out.println(this.name + "在学习");
    }
}

import com.mlt.oop.demo.Student;
//测试类
//一个项目应该只存在一个main方法
public class Application {
    public static void main(String[] args) {
        //类：抽象的，需要实例化
        //类实例化后会返回一个自己的对象
        //xiaohong对象就是一个Student类的具体实例
        Student xiaohong = new Student();
        Student xiaoming = new Student();

        xiaohong.name = "小红";
        xiaohong.age = 18;

        System.out.println(xiaohong.name);
        System.out.println(xiaohong.age);

        xiaoming.name = "小明";
        xiaoming.age = 17;

        System.out.println(xiaoming.name);
        System.out.println(xiaoming.age);

        xiaohong.study();
        xiaoming.study();
    }
}

类的构造器

• 特点：

  方法名和类名相同

  没有返回值

• 作用：

  new本质是在调用构造方法

  初始化对象的值

• 注意点：

  定义了有参构造器之后，如果还想使用无参构造器，必须要显式地定义一个无参的构造器。

  IDEA生成构造器快捷键：Alt+insert

代码：

//Person类
public class Person {

    String name;
    int age;

    //构造器
    //一个类即时什么也没写，它也会存在一个隐式的构造器方法（无参数）
    //1.使用new关键字，本质是在调用构造器
    //2.构造器可以用来初始化值
    //3.增加构造器的快捷键Alt+insert

    //无参构造器
    //如果一个构造器都没有，这就是隐式的构造器方法
    public Person(){
//        //构造器中可以实例化初始值
//        this.name = "麻辣烫";
    }

    //有参构造器
    //一旦定义了有参构造器，无参构造器必须显示定义，否则无参构造器将被覆盖
    public Person(String name){
        this.name = name;
    }

    //可以重载很多有参构造器
    public Person(String name, int age){
        this.name = name;
        this.age = age;
    }

}

import com.mlt.oop.demo.Person;
//测试类
//一个项目应该只存在一个main方法
public class Application {
    public static void main(String[] args) {

        //new 实例化了一个对象
        Person person = new Person("麻辣烫");

        System.out.println(person.name);

        Person person1 = new Person("麻辣烫", 33);

        System.out.println(person1.name);
        System.out.println(person1.age);
    }
}

创建对象内存分析

代码：

//宠物类
public class Pet {
   public String name;
   public int age;

   //无参构造器
   public Pet() {

   }
    public void shout() {
        System.out.println(this.name + "叫了一声");
    }
}

import com.mlt.oop.demo.Pet;
//测试类
//一个项目应该只存在一个main方法
public class Application {
    public static void main(String[] args) {

        Pet dog = new Pet();
        dog.name = "旺财";
        dog.age = 3;
        dog.shout();

        System.out.println(dog.name);
        System.out.println(dog.age);

        Pet cat = new Pet();

    }
}

内存分析示例图

面向对象三大特性

封装

• 该露的露，该藏的藏

  我们程序设计要追求“高内聚，低耦合”。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合就是仅暴露少量的方法给外部使用。

• 封装（数据的隐藏）

  通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。

• 记住这句话就够了：属性私有，get/set

封装的意义：

1. 提高程序的安全性，保护数据
2. 隐藏代码的实现细节
3. 统一接口
4. 系统的可维护性增加了

代码：

//类  private:私有
public class Student {

    //属性私有：private
    private String name; //名字
    private int id; //学号
    private char sex; //性别
    private int age; //年龄

    //提供可以操作类的属性的方法
    //public的get和set方法

    //get：获得数据
    public String getName(){
        return this.name;
    }

    //set：给数据赋值
    public void setName(String name){
        this.name = name;
    }

    //alt+insert 自动生成get/set方法
    public int getId(){
        return this.id;
    }

    public void setId(int id){
        this.id = id;
    }

    public char getSex() {
        return this.sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    public int getAge() {
        return this.age;
    }

    public void setAge(int age) {
        if (age < 0 || age > 100) { //不合法
            this.age = 3;
        } else {
            this.age = age;
        }

    }
}

import com.mlt.oop.demo04.Student;

//测试类
//一个项目应该只存在一个main方法
public class Application {
    public static void main(String[] args) {

        //封装
        Student student = new Student();
        student.setName("麻辣烫");
        String name = student.getName();
        System.out.println(name);

        student.setAge(99);
        System.out.println(student.getAge());
        student.setAge(-1);
        System.out.println(student.getAge());

    }
}

继承

• 继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。
• extends的意思是“扩展”。子类是父类的扩展。
• JAVA中类只有单继承，没有多继承！一个儿子只有一个爸爸，一个爸爸可以有多个儿子。
• 继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等。
• 继承关系的俩个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示。
• 在Java中，所有的类都默认直接或者间接继承Object类。
• 子类和父类之间，从意义上讲应该具有"is a"的关系。
• object类
• super
• 方法重写
• 被final修饰的类不能被继承

代码：

//在Java中，所有的类，都默认直接或者间接继承Object类
//Person 人：父类
public class Person {

    //修饰符（优先级从上到下）
    //public：优先级最高，子类可以访问
    //protected：子类可以访问
    //default：子类无法访问
    //private：子类无法访问

    private int money = 10_0000_0000;

    public void say() {
        System.out.println("说了一句话");
    }

    public int getMoney() {
        return this.money;
    }

    public void setMoney(int money) {
        this.money = money;
    }
}

//学生 is 人：派生类，子类
//子类继承了父类，就会拥有父类的全部方法！
//Ctrl + H 查看类的继承关系
public class Student extends Person{
}

import com.mlt.oop.demo05.Student;

//测试类
//一个项目应该只存在一个main方法
public class Application {
    public static void main(String[] args) {

        //继承
        Student student = new Student();
        student.say(); //子类继承父类的方法
        System.out.println(student.getMoney()); //父类的公共方法可以访问父类的私有属性

    }
}

super

• super注意点：

  super调用父类的构造方法，必须在构造方法的第一个。

  super必须只能出现在子类的方法或者构造方法中！

  super和 this不能同时调用构造方法！（因为super();和this();都必须在第一行）

• 与this的不同：

  • 代表的对象不同：

    this：本身调用者这个对象

    super：代表父类对象

  • 应用前提：

    this：没有继承也可以使用

    super：只能在继承条件才可以使用

  • 构造方法：

    this();本类的构造

    super();父类的构造

代码：

//Person 人：父类
public class Person {

    public Person() {
        System.out.println("Person无参执行了");
    }

    protected String name = "麻辣烫";

    public void print() {
        System.out.println("Person");
    }
}

//学生 is 人：派生类，子类
public class Student extends Person {

    public Student() {
        //隐藏代码：调用了父类的无参构造器
        super(); //调用父类的构造器，必须要在子类构造器的第一行
        System.out.println("Student无参执行了");
    }

    private String name = "凉皮";

    public void print() {
        System.out.println("Student");
    }

    public void test(String name) {
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.name);
    }

    public void test1() {
        print();
        this.print();
        super.print();
    }


}

import com.mlt.oop.demo05.Student;

//测试类
//一个项目应该只存在一个main方法
public class Application {
    public static void main(String[] args) {

        //super
        Student student = new Student();
        student.test("煎饼果子");
        student.test1();

    }
}

重写

重写：需要有继承关系，子类重写父类的方法！

• 特点：

  • 方法名必须相同

  • 参数列表必须相同

  • 修饰符：范围可以扩大但不能缩小 Public>Protected>Default>Private

  • 抛出的异常：范围，可以被缩小，但不能扩大。

    Exception(大) -->ClassNotFoundException

• 重写：子类的方法和父类必需要一致，只是方法体不同！

• 为什么要重写？

  父类的功能子类不一定需要，或者不一定满足！

• 快捷键：

  Alt + Insert ：override;

代码：

//继承
public class A extends B{

//    public static void test(){
//        System.out.println("A=>test()");
//    }

    //Override 重写
    @Override //注解：有功能的注释！
    public void test(){
        System.out.println("A=>test()");
    }

}

//重写都是方法的重写，和属性无关
public class B {

//    public static void test(){
//        System.out.println("B=>test()");
//    }

    public void test(){
        System.out.println("B=>test()");
    }

}

import com.mlt.oop.demo05.A;
import com.mlt.oop.demo05.B;

//测试类
//一个项目应该只存在一个main方法
public class Application {
    public static void main(String[] args) {

        A a = new A();
        
        //父类的引用指向了子类
        B b = new A();
        
        //静态方法和非静态方法区别很大
        //静态方法：方法的调用只和左边定义的数据类型有关
        //非静态方法：子类重写了父类的方法
        a.test(); //test()为static方法时，输出A=>test()，否则，也输出A=>test()
        b.test(); //test()为static方法时，输出B=>test()，否则，输出A=>test()

    }
}

java的访问权限

• public：对所有类可见。使用对象：类、接口、变量、方法。

• protected：对同一包内的类和所有子类可见。使用对象：变量、方法。注意：不能修饰类（外部类）

• default (即默认，什么也不写）：在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。

• private：在同一类内可见。使用对象：变量、方法。注意：不能修饰类（外部类）

多态

• 即同一方法可以根据发送对象的不同而采用多种不同的行为方式。
• 一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多。
• 多态存在的条件：
  • 有继承关系
  • 子类重写父类方法
  • 父类引用指向子类对象
• 注意：多态是方法的多态，属性没有多态性。
• instanceof 判断一个对象是什么类型。引用类型的类型转换。

多态注意事项

1. 多态是方法的多态，属性没有多态。

2. 父类和子类有联系，不然会报错类型转换异常! CLassCastException !

3. 存在条件：继承关系，方法需要重写，父类引用指向子类对象！

   Father f1 = new Son( );
   

不能重写的方法

1. static方法：属于类，不属于实例。
2. final方法：最终方法，在常量池中。
3. private方法：类私有的方法。

代码：

//父类
public class Person {

    public void run() {
        System.out.println("run");
    }

    //父类独有的方法
    public void play() {
        System.out.println("play");
    }
}

//子类
public class Student extends Person {

    //重写父类方法
    @Override
    public void run() {
        System.out.println("son run");
    }

    //子类独有的方法
    public void eat() {
        System.out.println("eat");
    }
}

import com.mlt.oop.demo06.Person;
import com.mlt.oop.demo06.Student;

//测试类
//一个项目应该只存在一个main方法
public class Application {
    public static void main(String[] args) {

        //多态
        //一个对象的实际类型是确定的
        new Student();
        new Person();

        //可以指向的引用类型就不确定了：父类的引用指向子类
        //Student 能调用的方法都是自己的或者继承父类的
        Student student = new Student();
        //Person 父类型，可以指向子类，但不能调用子类独有的方法
        Person person = new Student();
        Object object = new Student();

        //对象能执行的方法，主要看对象左边的类型，和右边关系不大！
        //父类独有的方法
        student.play(); //输出play。子类能调用父类的方法
        person.play(); //输出play

        //子类重写父类的方法
        student.run(); //输出son run
        person.run(); //输出son run。子类重写了父类的方法，父类引用执行子类的方法

        //子类独有的方法
        student.eat(); //输出eat
        //person.eat(); //父类不能调用子类独有方法：person无法执行eat()方法。
        ((Student) person).eat(); //输出eat。将父类person强制转换成子类Student类型就可以调用eat()方法。

    }
}

instanceof

boolean result = obj instanceof Class;　　

其中 obj 为一个对象，Class 表示一个类或者一个接口，当 obj 为 Class 的对象，或者是其直接或间接子类，或者是其接口的实现类，结果result 都返回 true，否则返回false。

注意：编译器会检查 obj 是否能转换成右边的class类型，如果不能转换则直接报错（编译不通过），如果不能确定类型，则通过编译，具体看运行时确定。

代码：

//父类
public class Person {
}

//子类
public class Student extends Person {
}

//子类
public class Teacher extends Person{
}

import com.mlt.oop.demo06.Person;
import com.mlt.oop.demo06.Student;
import com.mlt.oop.demo06.Teacher;

//测试类
//一个项目应该只存在一个main方法
public class Application {
    public static void main(String[] args) {
		
        //instanceof：判断一个对象是什么类型。
        //Object > String
        //Object > Person > Student
        //Object > Person > Teacher
        Object obj = new Student();
        System.out.println(obj instanceof Student); //true
        System.out.println(obj instanceof Person); //true
        System.out.println(obj instanceof Object); //true
        System.out.println(obj instanceof Teacher); //false
        System.out.println(obj instanceof String); //false
        System.out.println("=====================");
        Person per = new Student();
        System.out.println(per instanceof Student); //true
        System.out.println(per instanceof Person); //true
        System.out.println(per instanceof Object); //true
        System.out.println(per instanceof Teacher); //false
//        System.out.println(per instanceof String); //编译报错
        System.out.println("=====================");
        Student stu = new Student();
        System.out.println(stu instanceof Student); //true
        System.out.println(stu instanceof Person); //true
        System.out.println(stu instanceof Object); //true
//        System.out.println(stu instanceof Teacher); //编译报错
//        System.out.println(stu instanceof String); //编译报错
        //编译能否通过看左边，运行结果看右边。

    }
}

类型转换

多态的总结：

1. 父类引用指向子类的对象。
2. 把子类转换为父类，向上类型转换，自动转换，可能会丢失子类自己的方法。
3. 把父类转换为子类，向下类型转换，强制转换。
4. 方便方法的调用，减少重复的代码，简洁。

代码：

//父类
public class Person {
}

//子类
public class Student extends Person {

    //子类独有的方法
    public void go() {
        System.out.println("go");
    }
}

import com.mlt.oop.demo06.Person;
import com.mlt.oop.demo06.Student;

//测试类
//一个项目应该只存在一个main方法
public class Application {
    public static void main(String[] args) {
		
        //类型转换
        //高 ---------> 低
        Person student = new Student(); //自动向上类型转换
        //向上类型转换（子类转换为父类），可能丢失子类的一些方法。
        //student这个对象无法使用Student类独有的方法。
        //student.go(); //编译错误
        //将student这个对象强制转换为Student类，就可以使用Student类的方法了。
        ((Student)student).go(); //父类转化为子类，强制类型转换

    }
}

static关键字

• 静态变量
• 静态方法
• 静态代码块
• 静态导入

代码：

//static
public class Student {

    private static int age; //静态变量 多线程
    private double score; //非静态变量

    //非静态方法
    public void run() {
        System.out.println("run");
    }

    //静态方法
    public static void go() {
        System.out.println("go");
    }

    public static void main(String[] args) {
        Student s1 = new Student();
        System.out.println(Student.age); //输出0
        System.out.println(s1.age); //输出0
        System.out.println(s1.score); //输出0.0

        s1.run(); //输出run
        Student.go(); //输出go
        go(); //输出go

    }
}

public class Person {

    {
        //2.匿名代码块
        //创建对象的时候在创建构造器之前就自动创建了匿名代码块
        //程序执行的时候不能主动调用
        //作用：赋初值
        System.out.println("匿名代码块");
    }

    static {
        //1.静态代码块
        //类一加载就直接执行，永久只执行一次
        System.out.println("静态代码块");
    }

    //3.构造方法
    public Person() {
        System.out.println("构造方法");
    }

    public static void main(String[] args) {
        Person person1 = new Person();
        /*
         执行结果：
         静态代码块
         匿名代码块
         构造方法
        */
        Person person2 = new Person();
        /*
         执行结果：
         匿名代码块
         构造方法
        */
    }
}

//静态导入包
import static java.lang.Math.random;
import static java.lang.Math.PI;

public class Test {

    public static void main(String[] args) {
        System.out.println(random()); //输出一个随机数
        System.out.println(PI); //输出3.141592653589793
    }

}

抽象类

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

代码：

//abstract 抽象类
public abstract class Action {

    public Action() {
        System.out.println("抽象类构造器");
    }

    //约束~ 有人帮我们实现~
    //abstract 抽象方法，只有方法的名字，没有方法的实现！
    public abstract void doSomething();

    public void hello() {

    }

    /*
       抽象类的特点：
       1.不能new这个抽象类，只能靠子类去实现它：约束！
       2.抽象类中可以写普通方法。
       3.抽象方法必须在抽象类中！
       抽象的抽象：约束~

       思考题：
       1. 不能new？存在构造器吗？
          存在。抽象类的构造器不是用于创建对象，而是让子类通过super关键字调用这些构造器来完成属于抽象类的初始化工作。
       2. 抽象类的意义？
          提高开发效率：作为基类存在，用于指导其子类的设计和实现。
     */
}

//抽象类的所有方法，继承了该抽象类的子类都必须实现，除非这个子类也是抽象类。
public class A extends Action{

    public A() {
        System.out.println("子类构造器");
    }

    @Override
    public void doSomething() {

    }

    public static void main(String[] args) {
        A a = new A();
        /*
          执行结果：
          抽象类构造器
          子类构造器
        */
    }
}

接口

普通类、抽象类、接口三者的区别：

• 普通类：只有具体实现。

• 抽象类：具体实现和规范（抽象方法）都有！

• 接口：只有规范！自己无法写方法。专业的约束！约束和实现分离：面向接口编程。

理解：

• 接口就是规范，定义的是一组规则，体现了现实世界中“如果你是…则必须能…”的思想。如果你是天使，则必须能飞。如果你是汽车，则必须能跑。如果你好人，则必须干掉坏人；如果你是坏人，则必须欺负好人。

• 接口的本质是契约，就像我们人间的法律一样。制定好后大家都遵守。

• OO（面向对象）的精髓，是对对象的抽象，最能体现这一点的就是接口。为什么我们讨论设计模式都只针对具备了抽象能力的语言（比如c++、java、c等)，就是因为设计模式所研究的，实际上就是如何合理的去抽象。

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

作用和特点：

1. 约束
2. 定义一些方法，让不同的人实现~
3. public abstract 方法
4. public static final 常量
5. 接口不能被实例化，接口中没有构造方法~
6. implements 可以实现多个接口
7. 实现接口必须要重写接口中的方法

代码：

//interface 定义接口的关键字，接口都需要有实现类
public interface UserService {

    //接口中的所有定义的属性都是常量
    //public static final可以省略
//    public static final int AGE = 99;
    int AGE = 99;

    //接口中的所有定义的方法其实都是公共的、抽象的：public abstract
    //public abstract可以省略
//    public abstract void add(String name);
    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 UserServiceIml implements UserService, TimeService {

    //重写接口中的方法
    //快捷键：ctrl+i

    @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类来说就是外部类了。

// 外部类
class Outer{
  // 内部类
  class Inner{
    // 也会生成class文件
  }
}

特点：

• 编译之后可生成独立的字节码文件。
• 内部类可直接访问外部类私有成员，而不破坏封装。
• 可为外部类提供必要的内部功能组件。

成员内部类

• 在类的内部定义，与实例变量、实例方法同级别的类。
• 外部类的一个实例部分，创建内部类对象时，必须依赖外部类对象。
• 当外部类、内部类存在重名的属性和方法时，会优先访问内部类的属性和方法。
• 成员内部类里不能定义静态成员（static）、可以包含静态常量(static final)。

代码：

//外部类
public class Outer {

    //实例变量
    private int id = 1;
    private int age = 18;

    public void out() {
        System.out.println("这是外部类的方法");
    }

    //成员内部类
    public class Inner {

        private int id = 2;
        private String name = "麻辣烫";

        //private static String country = ""; 不能包含静态成员
        private static final String country = "中国";//但是能包含静态常量

        public void in() {
            out(); //内部类可以访问外部类的方法
            System.out.println("这是内部类的方法");
        }

        //获得外部类的私有属性
        public void getId() {
            //内部类可以访问外部类的私有属性
            //当外部类、内部类存在重名的属性和方法时，会优先访问内部类的属性和方法。
            System.out.println(Outer.this.id); //输出1
            System.out.println(age); //输出18

            //内部类属性
            System.out.println(id); //输出1
            System.out.println(this.id); //输出1
            System.out.println(country); //输出中国
        }
    }
}

import com.mlt.oop.demo10.Outer;

//测试类
//一个项目应该只存在一个main方法
public class Application {
    public static void main(String[] args) {

        //成员内部类
        //创建外部类对象
        Outer outer = new Outer();
        //通过这个外部类来实例化内部类~
        Outer.Inner inner1 = outer.new Inner();
        inner1.in();
        inner1.getId();
        //一步到位
        Outer.Inner inner2 = new Outer().new Inner();

    }
}

静态内部类

• 不依赖外部类对象，可直接创建或通过类名访问，可声明静态成员。

代码：

//外部类
public class StaticOuter {
    //实例变量
    private String name = "麻辣烫";
    private String address = "北京";

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

    //静态内部类，级别和外部类相同
    public static class StaticInner{
        private String address = "上海";

        // 静态成员
        private static int count = 1000;

        //方法
        public void show(){
            // 调用外部类的属性
            // 1. 先创建外部类对象
            StaticOuter staticOuter = new StaticOuter();
            // 2. 调用外部类对象的属性
            System.out.println(staticOuter.name); //输出麻辣烫
            System.out.println(staticOuter.address); //输出北京
            //调用静态内部类的属性和方法
            System.out.println(address); //输出上海
            //调用静态内部类的静态属性
            System.out.println(count); //输出1000
            System.out.println(StaticInner.count); //输出1000

            //访问外部方法
            staticOuter.eat();
        }
    }

}

import com.mlt.oop.demo10.StaticOuter;
import com.mlt.oop.demo10.StaticOuter.StaticInner;

//测试类
//一个项目应该只存在一个main方法
public class Application {
    public static void main(String[] args) {

        //静态内部类
        //直接创建静态内部类对象
        StaticOuter.StaticInner staticInner1 = new StaticOuter.StaticInner();
        staticInner1.show();
        //一步到位：导入静态内部类后可以直接使用
        StaticInner staticInner2 = new StaticInner();

    }
}

局部内部类

• 定义在外部类方法中，作用范围和创建对象范围仅限于当前方法。
• 局部内部类访问外部类当前方法中的局部变量时，因无法保障变量的生命周期与自身相同，变量必须修饰为final。
• 限制类的使用范围，只能在当前方法中使用。

代码：

//外部类
public class LocalOuter {
    //实例变量
    private String name = "刘德华";
    private int age = 35;

    //方法
    public void show(){
        // 定义局部变量
        String address = "sz";

        //局部内部类：注意不能加任何访问修饰符
        class LocalInner{
            private String phone = "11234";
            private String email = "[email protected]";
            //private static String country = ""; 不能包含静态成员
            private static final String country ="中国";//但是能包含静态常量

            public void show(){
                // 访问外部类的属性
                System.out.println(name); // 相当于 LocalOuter.this.name
                System.out.println(age);
                // 访问内部类的属性
                System.out.println(this.phone);
                System.out.println(this.email);

                // 访问局部变量 jdk1.7要求必须常量final、jdk1.8自动添加final
                System.out.println(address);
            }
        }
        // 创建局部内部类对象
        LocalInner LocalInner = new LocalInner();
        LocalInner.show();
        //address = "123"; 因为局部内部类访问了address，所以address默认为final常量，后面不能进行更改
    }

}

import com.mlt.oop.demo10.LocalOuter;

//测试类
//一个项目应该只存在一个main方法
public class Application {
    public static void main(String[] args) {

        //局部内部类
        LocalOuter localOuter = new LocalOuter();
        localOuter.show();

    }
}

匿名内部类

• 没有类名的局部内部类（一切特征都与局部内部类相同）。
• 必须继承一个父类或者实现一个接口。
• 定义类、实现类、创建对象的语法合并，只能创建一个该类的对象。
• 优点：减少代码量。
• 缺点：可读性较差。

代码：

//外部类
public class AnonymousOuter {
    public static void main(String[] args) {
        //匿名内部类：没有名字初始化类，不用将实例保存到变量中
        new Apple().eat(); //输出eat

        //使用匿名内部类实现接口（相当于创建了一个局部内部类）
        UserService userService = new UserService() {
            @Override
            public void hello() {
                System.out.println("Hello world!");
            }
        };
        userService.hello(); //输出Hello world!

        //简化写法
        (new UserService() {
            @Override
            public void hello() {
                System.out.println("Hello world!");
            }
        }).hello(); //输出Hello world!
    }
}

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

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

标签：java,String,void,System,面向对象,println,public,out
From： https://www.cnblogs.com/spicy-hot-pot/p/18383462