面向对象编程
面向过程 & 面向对象
- 面向过程思想
- 步骤清晰简单，第一步做什么，第二步做什么......
- 面对过程适合处理一些较为简单的问题
- 面向对象思想
- 物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索
- 面向对象适合处理复杂的问题，适合处理需要多人协作的问题！
- 对于描述复杂的事物，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是具体到微观操作，仍然需要面向过程的思路去处理
什么是面向对象
- 面向对象编程（Object-Oriented Programming，OOP）
- 面向对象编程的本质就是：以类的方式组织代码，以对象的组织（封装）数据
- 抽象：编程思想！持续的学习，茅塞顿开 ！多实践，多测试大脑中的想法！实践出真知~
- 三大特性：
- 封装
- 继承
- 多态
- 从认识论角度考虑是先有对象然后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象
- 从代码运行的角度考虑是先有类后有对象。类是对象的模板
回顾方法及加深
-
方法的定义
- 修饰符
- 返回类型
- break：跳出 switch 结束循环 和 return 的区别
- 方法名：注意规范就OK 见名知意
- 参数列表：（参数类型，参数名）...
- 异常抛出：疑问，后面讲解
package com.opp; import java.io.IOException; //Demo01 类 public class Demo01 { //main 方法 public static void main(String[] args) { } /* 修饰符 返回值类型 方法名(...) { //方法体 return 返回值; } */ //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 关键字
package com.opp;
public class Demo02 {
public static void main(String[] args) {
//实例化这个对象 new
//对象类型 对象名 = 对象值;
Student student = new Student();
student.say();
}
//和类一起加载的
public static void a() {
//b();
}
//类实例化 之后才存在
public void b() {
}
}
package com.opp;
//值传递
public class Demo04 {
public static void main(String[] args) {
int a = 1;
System.out.println(a);
Demo04.change(a);
System.out.println(a); //1
}
//返回值为空
public static void change(int a) {
a = 10;
}
}
package com.opp;
public class Demo05 {
public static void main(String[] args) {
Person person = new Person();
System.out.println(person.name); //null
Demo05.change(person);
System.out.println(person.name);
}
public static void change(Person person) {
//person是一个对象：指向的 ---> Person person = new person(); 这个是一个具体的人，可以改变属性！
person.name = "Blitz";
}
}
//定义了一个Person类，有一个属性：name
class Person {
String name;
}
类与对象的关系
- 类是一种抽象的数据类型，它是对某一类事物整体描述/定义，但是并不能代表某一个具体的事物
- 动物、植物、手机、电脑......
- Person类、Pet类、Car类等，这些类都是用来描述/定义某一类具体的事物应该具备的特点和行为
- 对象是抽象概念的具体实例
- 张三就是人的一个具体实例，张三家里的旺财就是狗的一个具体实例
- 能够体现除特点，展现出功能的是具体的实例，而不是一个抽象的概念
创建与初始化对象
-
使用new关键字创建对象
-
使用new关键字创建的适合，除了分配内存空间之外，还会给 创建好的对象 进行默认的初始化以及对类中构造器的调用
-
类中的构造器也成为构造方法，是在进行创建对象的适合必须要调用的。并且构造器有以下两个特点：
- 1.必须和类的名字相同
- 2.必须没有返回类型，也不能写 void
-
构造器必须要掌握
package com.opp.demo02; //一个项目应该只存在一个main方法 public class Application { public static void main(String[] args) { //类：抽象的，实例化 //类实例化后会返回一个自己的对象！ //student 对象就是一个Student类的具体实例！ Student xm = new Student(); Student xh = new Student(); xm.name = "小明"; xm.age = 3; System.out.println(xm.name); System.out.println(xm.age); xh.name = "小红"; xh.age = 3; System.out.println(xh.name); System.out.println(xh.age); } }package com.opp.demo02; //一个项目应该只存在一个main方法 public class Application { public static void main(String[] args) { //类：抽象的，实例化 //类实例化后会返回一个自己的对象！ //student 对象就是一个Student类的具体实例！ Student xm = new Student(); Student xh = new Student(); xm.name = "小明"; xm.age = 3; System.out.println(xm.name); System.out.println(xm.age); xh.name = "小红"; xh.age = 3; System.out.println(xh.name); System.out.println(xh.age); } }package com.opp.demo02; //java ---> class public class Person { //即使一个类什么都不屑，，它也会存在一个方法 //显示的定义构造器 String name; int age; //alt + insert //实例化初始值 //1.使用new关键字，本质是在调用构造器 //2.用来初始化值 public Person() { } //有参构造：一旦定义了有参构造，无参就必须显示定义 public Person(String name) { this.name = name; } public Person(String name, int age) { this.name = name; this.age = age; } } /* public static void main(String[] args) { //new 实例化了一个对象 //Person person = new Person(); Person person = new Person("Blitz", 99); System.out.println(person.name); } 构造器： 1.和类名相同 2.没有返回值 作用： 1.new 本质在调用构造方法 2.初始化对象的值 注意点： 1.定义有参构造后，如果想使用无参构造，显示的定义一个无参的构造 Alt + Insert this. = */package com.opp; import com.opp.demo02.Person; import com.opp.demo03.Pet; //一个项目应该只存在一个main方法 public class Application { public static void main(String[] args) { /* 1.类与对象 类是一个模板：抽象，对象是一个具体的实例 2.方法 定义、调用！ 3.对应的引用 引用类型：基本类型（8） 对象是通过引用来操作的：栈--->堆（地址） 4.属性：字段 Field 成员变量 默认初始化： 数字：0 0.0 char：u0000 boolean：false 引用：null 修饰符 属性类型 属性名 = 属性值！ 5.对象的创建和使用 - 必须使用 new 关键字创造对象，构造器 Person blitz = new Person(); - 对象的属性 blitz.name - 对象的方法 blitz.sleep() 6.类： 静态的属性 属性 动态的行为 方法 封装、继承、多态 */ } }
封装
-
该露的露，该藏的藏
- 我们程序设计要追求 ”高内聚，低耦合“ 。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用
-
封装（数据的隐藏）
- 通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏
-
记住这句话就够了：属性私有，get/set
package com.opp; import com.opp.demo04.Student; /* 1.提高程序的安全性，保护数据 2.隐藏代码的实现细节 3.统一接口 4.系统可维护性增加了 */ public class Application { public static void main(String[] args) { Student s1 = new Student(); s1.setName("Blitz"); System.out.println(s1.getName()); s1.setAge(999); //不合法的 System.out.println(s1.getAge()); } } /* //类 private：私有 public class Student { //属性私有 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 public int getId() { return id; } public void setId(int id) { this.id = id; } public char getSex() { return sex; } public void setSex(char sex) { this.sex = sex; } public int getAge() { return age; } public void setAge(int age) { if (age > 120 || age < 0) { //不合法 this.age = 3; }else { this.age = age; } } } */
继承
-
继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模
-
extends 的意思是“扩展”。子类是父类的扩展
-
JAVA中类只有单继承，没有多继承！
-
继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等
-
继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键词 extends来表示
-
子类和父类之间，从意义上讲应该具有 “is a” 的关系
-
object类
-
super
-
方法重写
package com.opp.demo05; //在Java中，所有的类，都默认直接或间接继承Object类 //Person 人：父类 public class Person /*extends Object*/ { //public //protected //default //private public int money = 10_0000_0000; public void say() { System.out.println("说了一句话"); } }package com.opp.demo05; //学生 is 人：派生类，子类 //子类继承了父亲，就会拥有父亲的全部方法！ public class Student extends Person { //Ctrl + H }package com.opp.demo05; //Teacher is 人：派生类，子类 public class Teacher extends Person { }package com.opp; import com.opp.demo05.Student; public class Application { public static void main(String[] args) { Student student = new Student(); student.say(); System.out.println(student.money); } }package com.opp.demo05; //在Java中，所有的类，都默认直接或间接继承Object类 //Person 人：父类 public class Person /*extends Object*/ { public Person() { System.out.println("Person无参执行了"); } protected String name = "blitz"; //私有的东西无法被继承！ public void print() { System.out.println("Person"); } }package com.opp.demo05; //学生 is 人：派生类，子类 //子类继承了父亲，就会拥有父亲的全部方法！ public class Student extends Person { public Student() { //隐藏代码：调用了父类的无参构造 super(); //调用父类的构造器，必须要在子类构造器的第一行 System.out.println("Student无参执行了"); } private String name = "kk"; public void print() { System.out.println("Student"); } public void test1() { print(); this.print(); super.print(); } public void test(String name) { System.out.println(name); System.out.println(this.name); System.out.println(super.name); } }package com.opp.demo05; //Teacher is 人：派生类，子类 public class Teacher extends Person { }note: super注意点： 1.super调用父类的构造方法，必须在构造方法的第一个 2.super 必须只能出现在子类的方法或者构造方法中！ 3.super 和 this 不能同时调用构造方法！ Vs this： 代表的对象不同： this：本身调用者这个对象 super：代表父类对象的应用 前提 this：没有继承也可以使用 super：只能在继承条件下才能使用 构造方法 this()：本类的构造 super()：父类的构造！ 重写：需要有继承关系，子类重写父类的方法！ 1.方法名必须相同 2.参数列表必须相同 3.修饰符：范围可以扩大： public > protected > default > private 4.抛出的异常：范围可以被缩小，但不能扩大：ClassNotFoundException --> Exception(大) 重写，子类的方法和父类必须要一致，方法体不同！ 为什么需要重写： 1.父类的功能：子类不一定需要，或者不一定满足！ Alt + Insert：Overridepackage com.opp.demo05; //继承 public class A extends B { //Override 重写 @Override //注解：有功能的注释！ public void test() { System.out.println("A=>test()"); } }package com.opp.demo05; //重写都是方法的重写，和属性无关 public class B { public void test() { System.out.println("B=>test()"); } }
多态
-
动态编译：类型：可扩展性
-
即同一方法可以根据发送对象的不同而采用多种不同的行为方式
-
一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多
-
多态存在的条件
- 有继承关系
- 子类重写父类方法
- 父类引用指向子类对象
-
注意：多态是方法的多态，属性没有多态性
-
instanceof （类型转换） 引用类型，判断一个对象是什么类型
package com.opp.demo06; public class Person { public void run() { System.out.println("run"); } } /* 多态注意事项： 1.多态是方法的多态，属性没有多态 2.父类和子类，有联系 类型转换异常！ ClassCastException! 3.存在条件：继承关系，方法需要重写，父类引用指向子类对象！ Father f1 = new Son(); 1.static 方法，属于类，它不属于实例 2.final 常量 3.private 方法 */package com.opp.demo06; public class Student extends Person { @Override public void run() { System.out.println("son"); } public void eat() { System.out.println("eat"); } }package com.opp; import com.opp.demo06.Person; import com.opp.demo06.Student; public class Application { public static void main(String[] args) { //一个对象的实际类型是确定的 //new Student(); //new Person(); //可以指向的引用类型就不确定了：父类的引用指向子类 //Student 能调用的方法都是自己的或者继承父类的！ Student s1 = new Student(); //Person 父类型，可以指向子类，但是不能调用子类独有的方法 Person s2 = new Student(); Object s3 = new Student(); //对象能执行哪些方法，主要看对象左边的类型，和右边关系不大！ ((Student) s2).eat(); //子类重写了父类的方法，执行子类的方法 s1.eat(); } }package com.opp.demo06; public class Person { public void run() { System.out.println("run"); } }package com.opp.demo06; public class Student extends Person { public void go() { System.out.println("go"); } } /* //Object > String //Object > Person > Teacher //Object > Person > Student Object object = new Student(); //System.out.println(X instanceof Y); //能不能编译通过！接口 System.out.println(object instanceof Student); //true System.out.println(object instanceof Person); //true System.out.println(object instanceof Object); //true System.out.println(object instanceof Teacher); //false System.out.println(object instanceof String); //false System.out.println("================"); Person person = new Student(); System.out.println(person instanceof Student); //true System.out.println(person instanceof Person); //true System.out.println(person instanceof Object); //true System.out.println(person instanceof Teacher); //false //System.out.println(person instanceof String); //编译报错！ System.out.println("======================="); Student student = new Student(); System.out.println(student instanceof Student); //true System.out.println(student instanceof Person); //true System.out.println(student instanceof Object); //true //System.out.println(student instanceof Teacher); //编译报错！ //System.out.println(student instanceof String); //编译报错！ */package com.opp.demo06; public class Teacher extends Person { }package com.opp; import com.opp.demo06.Person; import com.opp.demo06.Student; import com.opp.demo06.Teacher; public class Application { public static void main(String[] args) { //类型之间的转换： 父 子 //子类转换为父类，可能丢失自己的本来的一些方法！ Student student = new Student(); student.go(); Person person = student; } } /* 1.父类引用指向子类的对象 2.把子类转换为父类，向上转型 3.把父类转换为子类，向下转型：强制转换 4.方便方法的调用，减少重复的代码！简洁 抽象：封装、继承、多态！ 抽象类，接口 */package com.opp.demo07; public class Person { //2：赋初始值 { System.out.println("匿名代码块"); } //1：只执行一次 static { System.out.println("静态代码块"); } //3 public Person() { System.out.println("构造方法"); } public static void main(String[] args) { Person person1 = new Person(); System.out.println("==============="); Person person2 = new Person(); } }package com.opp.demo07; //static public class Student { private static int age; //静态的变量 private double score; //非静态的变量 public void run() { } public static void go() { } public static void main(String[] args) { go(); } }package com.opp.demo07; //静态导入包 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); } }
抽象类
-
abstract 修饰符可以用来修饰方法也可以修饰类，如果修饰方法，那么该方法就是抽象方法；如果修饰类，那么该类就是抽象类
-
抽象类中可以没有抽象方法，但是有抽象方法的类一定要声明为抽象类
-
抽象类，不能使用 new 关键字来创建对象，它是用来让子类继承的
-
抽象方法，只有方法的声明，没有方法的实现，它是用来让子类实现的
-
子类继承抽象，那么就必须要实现抽象类没有实现的抽象方法，否则子类也要声明为抽象类
package com.opp.demo08; //abstract 抽象类：类 extends：单继承~（接口可以多继承） public abstract class Action { //约束~有人帮我们实现~ //abstract 抽象方法，只有方法名字，没有方法的实现 public abstract void doSomething(); //1.不能new这个抽象类，只能靠子类去实现：约束！ //2.抽象类中可以写普通的方法~ //3.抽象方法必须在抽象类中~ //抽象的抽象：约束~ //思考题？ new， 存在构造器吗？ //存在的意义 抽象出来~提高开发效率 }package com.opp.demo08; //抽象类的所有方法，继承了它的子类，都必须要实现它的方法~除非子类也是abstract public class A extends Action { @Override public void doSomething() { } }
接口
-
普通类：只有具体实现
-
抽象类：具体实现和规范（抽象方法）都有！
-
接口：只有规范！自己无法写方法专业的约束约束和实现分离：mm面向接口编程~
-
接口就是规范，定义的是一组规则，体现了现实世界中“如果你是...则必须能...“的思想。如果你是天使，则必须能飞。如果你是汽车则必须能跑。如果你是好人，则必须干掉坏人；如果你是坏人，则必须欺负好人
-
接口的本质是契约，就像我们人间的法律一样。制定好后大家都必须遵守
-
OO的精髓，是对对象的抽象，最能体现这一点的就是接口。为什么我们讨论设计模式都只针对具备了抽象能力的语言（比如C++、java、C#等），就是因为设计模式所研究的，实际上就是如何合理的去抽象
package com.opp.demo09; import java.util.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() { } }package com.opp.demo09; //抽象的思维~Java //interface 定义的关键字，接口都需要有实现类 public interface UserService { //常量~public static final int AGE = 99; //接口中的所有定义都是抽象的 public abstract void add(String name); void delete(String name); void update(String name); void query(String name); }package com.opp.demo09; public interface TimeService { void timer(); }Note: 作用： 1.约束 2.定义一些方法，让不同的人实现~ 10 ---> 1 3.public abstract 4.public static final 5.接口不能被实例化~ 接口中没有构造方法~ 6.implements可以实现多个接口 7.必须要重写接口中的方法~ 8.总结博客~
内部类
-
内部类就是在一个类的内部再定义一个类，比如，A类中定义一个B类，那么B类相对于A类来说就成为内部类，而A类相对于B类来说就是外部类了
-
1.成员内部类
-
2.静态内部类
-
3.局部内部类
-
4.匿名内部类
package com.opp.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); } } }package com.opp; import com.opp.demo10.Outer; public class Application { public static void main(String[] args) { //new Outer outer = new Outer(); //通过这个外部类来实例化内部类~ Outer.Inner inner = outer.new Inner(); inner.getID(); } }package com.opp.demo10; public class Outer { //局部内部类 public void method() { class Inner { } } }package com.opp.demo10; public class Test { public static void main(String[] args) { //没有名字初始化类，不用将实例保存到变量中 new Apple().eat(); new UserService() { @Override public void hello() { } }; } } class Apple { public void eat() { System.out.println("1"); } } interface UserService { void hello(); }
什么是异常
- 实际工作中，遇到的情况不可能是非常完美的。比如：你写的某个模块，用户输入不一定符合你的要求、你的程序要打开某个文件，这个文件可能不存在或者文件格式不对，你要读取数据库的数据，数据可能是空的等。我们的程序在跑着，内存或硬盘可能满了。等等
- 软件程序在运行过程中，非常可能遇到刚刚提到的这些异常问题，我们叫异常，英文是：Exception，意思是例外。这些，例外情况，或者叫异常，怎么让我们写的程序做出合理的处理。而不至于程序崩溃
- 异常指程序运行中出现的不期而至的各种状况，如：文件找不到、网络连接失败、非法参数等
- 异常发生在程序运行期间，它影响了正常的程序执行流程
简单分类
- 要理解Java异常处理是如何工作的，你需要掌握以下三种类型的异常：
- 异常处理框架
- 检查性异常：最具代表的检查性异常是用户错误或问题引起的异常，这是程序员无法预见的。例如要打开一个不存在的文件时，一个异常就发生了，这些异常在编译时不能被简单地忽略
- 运行时异常：运行时异常是可能被程序员避免的异常。与检查性异常相反，运行时异常可以在编译时被忽略
- 错误ERROR：错误不是异常，而是脱离程序员控制的问题。错误在代码中通常被忽略。例如，当栈溢出时，一个错误就发生了，它们再编译时也检查不到的
异常体系结构
- Java把异常当作对象来处理，并定义一个基类java.lang.Throwable作为所有异常的超类
- 再Java API 中已经定义了许多异常类，这些异常类分为两大类，错误ERROR和异常Exception
Error
- Error类兑现相关由Java虚拟机生成并抛出，大多数错误与代码编写者所执行的操作无关
- Java虚拟机运行错误（Virtual MachineError），当JVM不再有继续执行操作所需的内存资源时，将出现OutOfMemoryError。这些异常发生时，Java虚拟机（JVM）一般会选择线程终止
- 还有发生再虚拟机试图执行应用时，如类定义错误（NoClassDefFoundError）、链接错误（LinkageError）。这些错误是不可查的，因为它们在应用程序的控制和处理能力之外，而且绝大多数是程序运行时不允许出现的状况
Exception
- 在Exception分支中有一个重要的子类RuntimeException（运行时异常）
- ArrayIndexOutOfBoundsException（数组下标越界）
- NullPointerException（空指针异常）
- ArithmeticException（算数异常）
- MissingResourceException（丢失资源）
- ClassNotFoundException（找不到类）等异常，这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理
- 这些异常一般是由程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这类异常发生
- Error和Exception的区别：Error通常是灾难性的致命的错误，是程序无法控制和处理的，当出现这些异常时，Java虚拟机（JVM)一般会选择终止线程；Exception通常情况下是可以被程序处理的，并且在程序中应该尽可能的去处理这些异常
异常处理机制
-
抛出异常
-
捕获异常
-
异常处理五个关键字
- try、catch、finally、throw、throws
- 快捷键：Ctrl + Alt + T
package com.exception; public class Test { public static void main(String[] args) { int a = 1; int b = 0; //假设要捕获多个异常：从小到大！ try {//try监控区域 if (b == 0) {//主动的抛出异常 throw throws throw new ArithmeticException(); //主动的抛出异常 } } catch (Error e) {//catch(想要捕获的异常类型)捕获异常 System.out.println("Error"); } catch (Exception e) { System.out.println("Exception"); } catch (Throwable t) { System.out.println("Throwable"); } finally {//处理善后工作 System.out.println("finally"); //finally 可以不要finally，假设IO，资源，关闭！ } } public void a() { b(); } public void b() { a(); } }package com.exception; public class Test { public static void main(String[] args) { try { new Test().test(1, 0); } catch (ArithmeticException e) { e.printStackTrace(); } } //假设这个方法中，处理不了这个异常，方法上抛出异常 public void test(int a, int b) throws ArithmeticException { if (b == 0) {//主动的抛出异常 throw throws throw new ArithmeticException(); //主动的抛出异常, 一般在方法中使用 } System.out.println(a / b); } }
自定义异常
-
使用Java内置的异常类可以描述在编程时出现的大部分异常情况。除此之外，用户还可以自定义异常。用户自定义异常类，只需继承Exception类即可
-
在程序中使用自定义异常类，大体可分为以下几个步骤：
- 创建自定义异常类
- 在方法中通过throw关键字抛出异常对象
- 如果在当前抛出异常的方法中处理异常，可以使用try-catch语句捕获并处理；否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常，继续进行下一步操作
- 在出现异常方法的调用者中捕获并处理异常
package com.exception; //自定义的异常类 public class MyException extends Exception { //传递数字>10; private int detail; public MyException(int a) { this.detail = a; } //toString:异常的打印信息 @Override public String toString() { return "MyException{" + "detail=" + detail + '}'; } }package com.exception; public class Test { //可能会存在异常的方法 static void test(int a) throws MyException { System.out.println("传递的参数为：" + a); if (a > 10) { throw new MyException(a); //抛出 } System.out.println("OK"); } public static void main(String[] args) { try { test(11); } catch (MyException e) { System.out.println("Myexception=>" + e); } } }
实际应用中的经验总结
- 处理运行时异常时，采用逻辑去合理规避同时辅助 try-catch 处理
- 在多重catch块后面，可以加一个catch（Exception）来处理可能会被遗漏的异常
- 对于不确定的代码，也可以加上try-catch，处理潜在的异常
- 尽量去处理异常，切记只是简单地调用 printStackTrace() 去打印输出
- 具体如何处理异常，要根据不同的业务需求和异常类型去决定
- 尽量添加finally语句块去释放占用的资源，IO~ Scanner~
浙公网安备 33010602011771号