Java——Object

1.Object万类之祖

1.1 Object类型的概述

Object类是所有类型的顶层父类，所有类型的直接或者间接的父类；所有的类型中都含有Object类中的所有方法。
随意定义一个类型,不手动显式定义其父类，那么这个类的父类就是Object类
public Object() {

}
Object类的构造方法：Object()
- 可以自己创建对象
- 让子类访问,所有子类都会直接或者间接的访问到这个顶层父类的构造方法
- Object类在执行构造方法时，不去访问自己的父类，因为没有父类了

1.2 getClass()

返回当前对象的运行时类
- 目前记住其中Class类型中有一个getName，可以返回当前类型的全类名
示例

public class Demo {public static void main(String[] args) {Demo demo = new Demo();System.out.println(demo.getClass().getName());}
}

1.3 hashCode()

根据对象的情况，生成的一个整数，就是哈希码值。生成数字的方法就是hashCode方法，它是一个特征值。
示例：

public class Demo {public static void main(String[] args) {Demo demo = new Demo();System.out.println(demo.hashCode());demo = new Demo();System.out.println(demo.hashCode());}
}

1.4 toString方法

返回当前对象的字符串表示
对象返回一个地址值的字符串，没有什么意义
最终操作：不需要手动重写，可以直接使用快捷键生成：Alt+Insert
使用打印语句打印一个对象，其实打印的就是这个对象的toString内容

1.5 equals

用于比较两个对象是否相等的方法，比较的就是“调用者”和“参数”这两个对象

boolean equals(Object obj)

在Object类型中，是比较两个对象的地址值是否相同。

实际生活中，比较两个对象的内存地址，没有什么意义。因此在自定义的子类中，都要重写这个方法。
- 按照自定义的方式比较两个对象是否相同
重写原则：
- 一般比较两个对象中的所有属性，是否全部相同
- <比如两个对象的name值相同，那么两个对象就相同>
代码实例

public class Simple01 {public static void main(String[] args) {Cat cat1 = new Cat("咪咪");Cat cat2 = new Cat("咪咪");boolean bool = cat1.equals(cat2);System.out.println(bool);// 表示获取全类名 包 +类名System.out.println(cat1.getClass());}
}class Cat {private String name;public String getName() {return name;}public Cat(String name) {this.name = name;}public void setName(String name) {this.name = name;}@Overridepublic boolean equals(Object o) {if (this == o) return true;if (o == null || getClass() != o.getClass()) return false;Cat cat = (Cat) o;return this.getName().equals(cat.getName());}
}

1.6 ==和equals方法的区别

相同点
- ==和equals都是用于比较数据是否相等的方式
不同点：
- 比较内容的不同：
  - ==可以比较任意数据类型，既可以比较基本数据类型，也可以比较引用数据类型
  - equals方法只能比较引用数据类型
- 比较规则不同：
  - ==在比较基本类型的时候，比较的是数据的值；比较引用类型时，比较的是地址值
  - equals方法在重写之前，比较的是两个对象的地址值；在重写之后，比较的属性值也就是类里面的属性值的大小。

2.内部类

2.1内部类的概述

定义在内部的类，就是内部类。可以定义在类的内部,可以定义在方法的内部。
根据定义的位置不同，可以分为：

成员内部类
- 普通的成员内部类
- 私有的成员内部类
- 静态的成员内部类
局部内部类
匿名内部类

2.2普通的成员内部类

定义在成员位置上的类，就是成员内部类
定义格式：
class 内部类类名 {
内部类成员
}
成员内部类的说明：
- 内部类可以直接访问外部类的所有成员，包括私有成员
- 外部类访问内部类的成员，必须先创建内部类的对象
- 在外部类以外，创建内部类的对象的格式：
  - 外部类名.内部类名内部类对象名 = new 外部类名().new 内部类名();
代码实例：

/*** 普通成员内部类*/
public class Simple02 {public static void main(String[] args) {Body.Heart heart = new Body().new Heart();heart.show();}
}//类嵌套类\
class Body {private double height = 1.74;class Heart {int beats = 90;public void show() {System.out.println("身高是" + height + ",心跳每分钟" + beats);}}}

2.3私有的成员内部类

也是一个成员内部类，在成员内部类前面加上一个private关键字
访问方式说明：
- 在外部类以外，不能直接访问外部类中的私有成员内部类
- 可以在外部类中，定义一个访问私有内部类的公有方法，让外界可以调用公有方法，间接的访问外部类中的私有成员内部类。
代码示例:

public class Simple02 {public static void main(String[] args) {Body body = new Body();body.test();}
}//类嵌套类\
class Body {private double height = 1.79;private class Heart {int beats = 90;public void show() {System.out.println("身高是" + height + ",心跳每分钟" + beats);}}public void test() {Heart hh = new Heart();hh.show();}
}

2.4 静态的成员内部类

也是一个成员内部类，在成员内部类前面加上一个static关键字
访问特点：
- 静态内部类中的非静态成员，需要将所在的内部类对象创建出来之后，才能被调用。
- 静态内部类中的静态成员,可以通过外部类名.内部类名的方式直接访问，而不需要创建外部类的对象
- 总结：一个类是否需要创建对象，不取决于该类本身是否是静态，而取决于要访问的成员是否是静态
- 静态成员内部类的对象创建格式：
- 外部类名.内部类名内部类对象名 = new 外部类名.内部类名();
- 代码实例
- ```
public class Simple03 {public static void main(String[] args) {// 方式一：外部类名.内部类名 内部类对象名 = new 外部类名.内部类名();Body2.Liver liver = new Body2.Liver();liver.show();// 方式二：外部类名.内部类名的方式直接访问System.out.println(Body2.Liver.FUNC);}}class Body2 {private double weight = 180;static class Liver {String color = "black";static final String FUNC = "解毒";void show() {System.out.println("肝都变成" + color + "色了，少整点吧！");}}
}
```

2.5局部内部类

定义在方法中的内部类

说明：

问题：属于方法中的局部变量，外界都没有办法访问到
解决方式:在方法内部定义调用方式
代码示例：

public class Simple3 {public static void main(String[] args) {new Body2().methodTest();}}class Body2 {void methodTest () {class SeaFood {void eat () {System.out.println("喝酒不能吃海鲜");}}new SeaFood().eat();}}

2.6 匿名内部类【常用】

没有名字的内部类
匿名内部类的使用前提：
- 匿名类：继承一个类
- 匿名类：实现一个接口
格式：
new 父类类名或者接口名() {
父类方法的重写或者是接口内容的实现
}
本质：创建了一个类的子类对象、接口的实现类对象
示例代码

public class Simple04 {public static void main(String[] args) {// 父 new 子Games games = new MyGames();games.play("LOL");// 匿名内部类new Games() {@Overridepublic void play(String name) {System.out.println("会玩" + name);}}.play("王者荣耀");// 拉姆达表达式Games games1 = (name) -> System.out.println("会玩" + name);games1.play("三国杀");}
}interface Games {void play(String name);
}class MyGames implements Games {@Overridepublic void play(String name) {System.out.println("会玩" + name);}
}

3.String

3.1概述

String就是字符串类型，属于java.lang包，不需要导包
所有的字符串常量"Hello World","abc"都属于String类型的对象
字符串字面值属于常量，存储在方法区的常量池中。
String类型是一个常量，在创建之后就无法更改（是一个不可变的字符序列）。
不可变的原因是String类型只提供了构造方法，没有提供set方法，因此只能在创建对象的时候，初始化成员变量，将来对象创建完成之后，无法通过方法来修改。
代码示例:

public class Simple05 {public static void main(String[] args) {String str2 = "abc";System.out.println(str2);//abcstr2 = "xyz";System.out.println(str2);//xyz}
}

3.2 String类型的构造方法

String()：创建一个空字符串
String(String original)：创建参数字符串的一个副本（字符串是在常量池中，构造方法创建的字符串是在堆内存中）
String(byte[] arr)：将一个字节数组转成一个字符串,将我们不认识的字节数组，转成了我们认识的字符串，过程叫做【解码】查询的是当前平台默认的编码表
String(byte[] arr, int offset, int length)：将字节数组的一部分转成字符串
String(char[] arr)：将字符数组转成字符串
- 既不是编码，也不是解码，只不过是把字符串成了串
String(char[] arr, int offset, int length)：将字符数组的一部分转成字符串
代码示例：

public class Simple06 {public static void main(String[] args) {//test1_空参构造();//test2_原始字符串转换();//test3_字节数组转字符串();test4_字符数组转成字符串();}private static void test4_字符数组转成字符串() {char[] arr = {'a', 'b', 'X', 'Y'};String str1 = new String(arr);System.out.println(str1);//abXY  只是组成字符串而已//将字符 数组的一部分转成字符串，String str2 = new String(arr, 1, 2);System.out.println(str2);//bX}private static void test3_字节数组转字符串() {//将整个字节数组转成了字符串byte[] bytes = {99, 111, 100, 105, 110, 103, 45, 102, 117, 116, 117, 114, 101};String s = new String(bytes);System.out.println(s);/*将字节数组的一部分转成字符串，* 其中offset是从哪个索引开始，length表示要将多少个字节是转成字符串*/byte[] arr = {99, 111, 100, 105, 110, 103, 45, 102, 117, 116, 117, 114, 101};String str2 = new String(arr, 1, 4);System.out.println(str2);}private static void test2_原始字符串转换() {String str = new String("abc");//这个对象，在堆内存中//"abc"常量，在方法区的常量池//new String("abc")这个对象，在堆内存中//str指向了堆内存中的对象System.out.println(str);//abcSystem.out.println(str == "abc");//falseSystem.out.println("abc" == "abc");//true}public static void test1_空参构造() {String str = new String();System.out.println(str);}
}

3.3 String类型的判断功能

equals(Object obj)：判断调用者和参数对象描述的字符串内容是否相同
equalsIgnoreCase(String otherStr)：忽略大小写判断两个字符串内容是否相同
contains(String str)：判断调用者是否包含了str这个子串
startsWith(String prefix)：判断调用者是否以prefix开头
endsWith(String suffix)：判断调用者是否以suffix结尾
isEmpty()：判断调用者是否是空串
代码示例

public class Simple07 {public static void main(String[] args) {
//        test1_equals();
//        test2_equalsIgnoreCase();
//        test3_包含();
//        test4_5_判断开始和结束();
//        test6_判断为空();}private static void test6_判断为空() {String str = "abc";System.out.println(str.isEmpty());//false  字符串不为null}private static void test4_5_判断开始和结束() {String str = "abcdefg";System.out.println(str.startsWith("abc"));//trueSystem.out.println(str.startsWith("abd"));//fasleSystem.out.println(str.startsWith("cde"));//falseSystem.out.println(str.endsWith("efg"));//true}private static void test3_包含() {String str1 = "abcdefg";System.out.println(str1.contains("abc"));//trueSystem.out.println(str1.contains("efg"));//trueSystem.out.println(str1.contains("cde"));//trueSystem.out.println(str1.contains("ace"));//false 必须是连续的}private static void test2_equalsIgnoreCase() {String str1 = "abcDEF";String str2 = "abcdef";System.out.println(str1.equals(str2));//false 字符串不相等//忽略大小写判断两个字符串内容是否相同System.out.println(str1.equalsIgnoreCase(str2));//true}private static void test1_equals() {String str1 = new String("abc");//在堆中String str2 = new String("abc");System.out.println(str1 == str2);//false 两个对象地址不一样 new了两次System.out.println(str1.equals(str2));//true  指向同一个对象}
}

3.4 String类型的获取功能

length()：获取字符串字符的个数
charAt(index)：返回调用者字符串中索引为index的字符（和length方法结合之后可以遍历字符串）
substring(int beginIndex)：获取一个字符串，内容是从当前字符串的beginIndex索引开始，一直到最后一个字符机截止
substring(int beginIndex, int endIndex)：获取一个指定索引范围的子串
- 注意事项：1、包含头不包含尾，返回的结果中，不包含endIndex索引指向的字符；2、所有的方法都无法修改字符串对象本身，一般都是返回一个新的字符串对象
indexOf家族：
- indexOf(int ch)：返回ch字符在当前调用者字符串中，第一次出现的索引
- indexOf(int ch, int fromIndex)：从fromIndex索引开始寻找，找到ch字符在当前字符串中第一次出现的索引
- indexOf(String str)：返回的是str这个字符串在调用者字符串中第一次出现的索引
- indexOf(String str, int fromIndex)：从fromIndex索引开始寻找，找到str字符串在当前字符串中第一次出现的索引（注意：无论从哪个位置开始找，所有字符的索引都不会变化）
lastIndexOf家族：
- 和IndexOf基本一样，只不过是从后往前找，所有字符和字符串的索引也都不会发生变化
示例代码

public class Simple08 {public static void main(String[] args) {test1_length();test2_charAt();test3_字符串遍历();test4_获取子串();test5_indexOf();test6_lastIndexOf();}private static void test6_lastIndexOf() {String str = "abcdabcd";System.out.println(str.lastIndexOf('c'));System.out.println(str.lastIndexOf('c', 5));System.out.println(str.lastIndexOf("cd"));System.out.println(str.lastIndexOf("cd", 5));}private static void test5_indexOf() {String str = "abcdabcd";//返回第一个c出现的索引System.out.println(str.indexOf('c'));System.out.println(str.indexOf('c', 3));System.out.println(str.indexOf("cd"));//2System.out.println(str.indexOf("cd", 3));}private static void test4_获取子串() {String str = "abcdefg";String result = str.substring(3);//str本身不会变化，因为字符串对象是一个不可变的字符序列System.out.println(str);//substring可以返回一个新的字符串对象System.out.println(result);//通过两个参数的substring获取子串System.out.println(str.substring(2, 5));}private static void test3_字符串遍历() {String str = "abcdefg";//遍历字符串for (int i = 0; i < str.length(); i++) {System.out.println(str.charAt(i));}}private static void test2_charAt() {String str = "abcdefg";char c = str.charAt(3);System.out.println(c);}private static void test1_length() {String str = "abcdefg";System.out.println(str.length());}
}

3.5 String类型的转换功能

byte[] getBytes()：将当前字符串，转成字节数组(编码)
char[] toCharArray()：将当前的字符串，转成字符数组
toUpperCase()：将当前的字符串，转成全大写形式
toLowerCase()：将当前的字符串，转成全小写形式
concat(String str)：将当前调用者，和参数str进行拼接，返回拼接后的长字符串（不常用，因为更多使用的是运算符+）
valueOf家族：可以将任意数据类型的数据，转换成字符串 (静态方法)
代码示例：

public class Simple09 {public static void main(String[] args) {test1_getBytes();test2_toCharArray();test3_upperAndLower();test4_concat();test5_valueOf();}private static void test5_valueOf(){//可以将任意数据类型的数据，转换成字符串System.out.println(String.valueOf(false));System.out.println(String.valueOf('x'));System.out.println(String.valueOf(new char[] {'a', 'b'}));System.out.println(String.valueOf(100));Object obj = null;System.out.println(String.valueOf(obj));}private static void test4_concat() {String str = "abc";String result = str.concat("xyz");System.out.println(result);System.out.println(str + "xyz");//将当前调用者，和参数str进行拼接，返回拼接后的长字符串（不常用，因为更多使用的是运算符+）}private static void test3_upperAndLower() {String str = "aBCdEfG";String upper = str.toUpperCase();//：将当前的字符串，转成全大写形式System.out.println(str);System.out.println(upper);String lower = str.toLowerCase();//：将当前的字符串，转成全小写形式System.out.println(lower);}private static void test2_toCharArray() {String str = "abcdefg";char[] arr = str.toCharArray();//将当前的字符串，转成字符数组for (int i = 0; i < arr.length; i++) {System.out.print(arr[i] + "\t");}System.out.println();}private static void test1_getBytes() {String str = "abc";byte[] arr = str.getBytes();//将当前字符串，转成字节数组(编码)for (int i = 0; i < arr.length; i++) {System.out.println(arr[i]);}}
}

3.6 String类型的其他方法

replace(String oldStr, String newStr)：将调用者中的老串替换成新串
trim()：去掉字符串左右两边的空格、制表符

split：

split(String regex, int limit)：字符串按照某个字符串进行分割，返回字符串数组，且限制返回元素个数。
split()：不限制返回元素个数。
String str = "Hello,World!com.coding-future";
String[] s = str.split("[,!.-]");
System.out.println(Arrays.toString(s));
}
format
String str = String.format("我是%s人，我爱%s","中国","中国");
代码示例

public class Simple10 {public static void main(String[] args) {test2_trim();test1_replace();}//去掉字符串左右两边的空格、制表符private static void test2_trim() {String str = "  I love java,  java is good ";String result = str.trim();System.out.println(str);System.out.println(result);}//将调用者中的老串替换成新串private static void test1_replace() {String str = "I love java, java is good";String result = str.replace("java", "study");System.out.println(str);System.out.println(result);}
}

4. StringBuffer && StringBuilder

4.1概述

内存理解:

public class Simple11 {public static void main(String[] args) {String[] strArr = {"java", "javascript", "html", "css", "nodejs"};String s1 = "我会的技能有：";for (String s : strArr) {s1 += s;s1 += ",";}System.out.println(s1);}
}

StringBuilder是一个可变的字符序列，因为在类中提供了修改私有成员变量的方法
- 常用的方法是append和insert，就是在StringBuilder对象本身上，进行修改操作
String类型和StringBuilder的关系：都是用于描述字符串
- String是不可变的字符序列，没有提供修改私有成员的方法；StringBuilder是可变的字符序列，因为提供了修改成员变量的方法；
- String长度本身也不可以变化，StringBuilder长度可以变化，可以认为StringBuilder就像一个可以伸缩的容器，用于存储字符

4.2构造方法

构造方法作用：创建当前对象、将其他类型的数据，转换成当前类型
StringBuilder的构造方法：
- StringBuilder()：创建一个生成器，初始容量为16个字符
- StringBuilder(int capacity)：创建一个生成器，初始容量为capacity大小
- StringBuilder(String str)：创建一个生成器，初始值就是str这些字符，初始大小是str+16
获取容积的方法：
- capacity()：获取当前生成器的容器大小
- length()：获取当前生成器中的字符个数
代码示例

public class Simple12 {public static void main(String[] args) {StringBuilder sb1 = new StringBuilder();System.out.println(sb1.capacity());//16StringBuilder sb2 = new StringBuilder(10);System.out.println(sb2.capacity());//10StringBuilder sb3 = new StringBuilder("Hello");System.out.println(sb3.capacity());//21System.out.println(sb3.length());//字符个数是5}
}

4.3添加功能

append(任意类型)：可以将任意数据类型，转成字符，添加到生成器中
insert(int index, 任意数据类型)：可以将任意数据类型，添加到指定的位置
- index的范围是0~当前缓冲区的大小
- 插入数据之后，数据本身的索引就是参数中指定的index
实例代码

private static void test1insert() {StringBuilder sb1 = new StringBuilder();//"1"sb1.insert(0, "a");System.out.println(sb1);//1sb1.insert(0, "b");System.out.println(sb1);//basb1.insert(1, "xyz");System.out.println(sb1);//bxyza}

4.4删除功能

deleteCharAt(int index) ：删除指定索引的字符
delete(int start, int end)：删除指定范围的字符，被删除的部分包含头不包含尾
实例代码

public class Simple13 {public static void main(String[] args) {//test1_deleteCharAt();test2_delete();}private static void test2_delete() {StringBuilder sb1 = new StringBuilder("abcdef");//删除cdsb1.delete(2, 4);System.out.println(sb1);//abef}private static void test1_deleteCharAt() {StringBuilder sb1 = new StringBuilder("abcdefg");sb1.deleteCharAt(2);System.out.println(sb1);//abdefg  删除指定索引的字符sb1.deleteCharAt(6);//String索引越界异常System.out.println(sb1);}
}

4.5替换和反转功能

replace(int start, int end ,String str)：
- 将字符串缓冲区中的从start开始到end-1这部分内容，替换成str
reverse()：将原有字符序列进行反转
示例代码

public class Simple14 {public static void main(String[] args) {test1_replace();test2_reverse();}private static void test2_reverse() {StringBuilder sb1 = new StringBuilder("abcdefg");sb1.reverse();System.out.println(sb1);}private static void test1_replace() {StringBuilder sb1 = new StringBuilder("abcdefg");sb1.replace(2, 5, "qq");System.out.println(sb1);}
}

4.6.StringBuffer和StringBuilder的区别

共同点：
- 都是字符串的缓冲区，都是字符串的生成器，都是可变的字符序列
不同点：
- 出现版本不同：
  - StringBuffer在jdk1.0出现的
  - StringBuilder在jdk1.5出现的
- 线程安全性不同：
  - StringBuffer是线程安全的，在多线程环境下仍然保证数据安全
  - StringBuilder是线程不安全，在多线程环境下无法保证数据安全
- 效率不同：
  - StringBuffer效率低
  - StringBuilder效率高

5.包装类

5.1概述

class Test {String str = "50";int a = (int) str; //此方式是否可以将str转成int类型int age = null; // 是否可以这样操作？
}

基本数据类型有八种，都是非常简单的数据类型
在这些类型中，只能表示简单的数据，不能包含一些操作数据的方法，没有办法存储描述这些数据的内容。需要准备一个引用数据类型，能将基本数据类型进行包装，提供一些操作基本类型的方法，定义一些描述数据的数据。
基本类型的包装类：
- byte Byte
  short Short
  int Integer类型
  long Long
  float Float
  double Double
  char Character
  boolean Boolean
各种包装类型的方法、特点基本相同，只要学习一个Integer类型，其他的也触类旁通。
Integer类型的对象中，维护了一个私有的成员变量，是一个int类型的字段（成员变量、属性），用于表示这个Integer对象要表示的数字。
提供了在int、Integer、String类型之间相互转换的方法

byte Byte
short Short
int Integer类型
long Long
float Float
double Double
char Character
boolean Boolean

5.2 Integer的构造方法

Integer(int i)：将一个基本类型的int数，转换成Integer类型的对象使用i给Integer对象中的成员变量赋值
Integer(String s)：将一个字符串类型的数字，转换成Integer类型的对象转换的作用
示例代码

public class Simple15 {public static void main(String[] args) {//将一个基本类型的int数，转换成Integer类型的对象使用i给Integer对象中的成员变量赋值Integer it = new Integer(100);System.out.println(it);//将一个字符串类型的数字，转换成Integer类型的对象转换的作用Integer it1 = new Integer("100");System.out.println(it1 + 10);}
}

5.3 Integer、int、String类型互相转换的总结

Integer转换成int类型
- intValue()
int转换成Integer类型
- 构造方法Integer(int i)
Integer到String的转换
- toString方法即可
String到Integer的转换
- Integer.valueOf(String str)
int转换成String类型：
- Integer.toString(int i)

String转换成int类型

Integer.parseInt(String str)

public class Simple16 {public static void main(String[] args) {Integer it2 = 10;int i = it2.intValue(); // i 没有操作方法Integer it3 = new Integer(20);System.out.println(it3);// it3有操作方法String s = it3.toString();System.out.println(s);// 字符串Integer it4 = Integer.valueOf(s);System.out.println(it4); // IntegerString s1 = Integer.toString(i);System.out.println(s1);// 字符串int i1 = Integer.parseInt(s1);System.out.println(i1);// int 类型}
}

5.4 自动装箱和拆箱

装箱和拆箱：
- 装箱：将基本数据类型，封装成包装类型的对象(引用类型)，这个过程就是装箱，使用构造方法即可
- 拆箱：从包装类型的对象中，将其包装的基本类型的数据取出，这个过程就是拆箱，使用intValue方法即可
自动装箱和拆箱
- 自动装箱：可以直接使用基本类型的数据，给引用类型的变量赋值
- 自动拆箱：可以直接使用包装类对象，给基本类型的变量赋值:包装类对象直接进行算数运算
示例代码

public class Simple17 {public static void main(String[] args) {Integer it = 100;//自动装箱，100基本数据类型给integer包装类型赋值int i = it;//自动拆箱，System.out.println(it + 1);//自动拆箱  变成基本类型 然后运算Integer inte = 100; // 先装箱inte = inte + 1;//先自动拆箱，计算，最后自动装箱}private static void test1_装箱和拆箱() {int i = 100;Integer it = new Integer(i);//装箱int j = it.intValue();//拆箱}
}

6. 包(package)

包：用于分类存放类文件(.class)的文件夹，在out/production目录下存放.class
作用：
- 包帮助管理大型软件系统:将功能相近的类划分到同一个包中。比如:MVC的设计模式
- 包可以包含类和子包，划分项目层次，便于管理
- 使用package声明类或接口所属的包,声明在源文件的首行
- 解决类命名冲突的问题,同一个包下,不能命名相同的类和接口,不同的包下,可以命名同名的类和接口。
- 每"."一次,就代表一层文件目录。
命名：域名倒着写：com.xxxx.www（全球唯一）
包的声明：使用package的关键字，声明当前的类是属于指定的包的。
效果：
- 编译的这个类，就会进入到一个指定的文件夹中。
- 当前的类，名称也发生了变化，类名变成了【包名 + 类名】
简化：

每次使用其他包的类的时候，都需要写很长一串全类名，所以非常麻烦，需要简化. 使用import语句进行简化，在类的声明上，写一个import语句，将这个类的全类名导入进来，在该类中，就可以直接使用这个类的简写形式了。
注意事项：
- 在源文件中使用import显式的导入指定包下的类或接口
- 声明在包的声明和类的声明之间。
- 如果导入的类或接口是java.lang包下的，或者是当前包下的，则可以省略此import语句。 System, String...
- 如果需要导入多个类或接口，那么就并列显式多个import语句即可
- 可以使用java.util.*的方式，一次性导入util包下所有的类或接口,不建议使用import *，使用import到类名。