一、类及类的成员：属性、方法、构造器、代码块、内部类
1、属性 = 成员变量 = field = 域，字段
属性(成员变量) vs 局部变量
1.相同点
1.1定义变量的格式 数据类型 变量名 = 变量值
1.2先声明，后 使用
1.3变量都有其对应的作用域
2.不同点
2.1在类中声明的位置不同
属性：直接定义在类的{}中
局部变量：声明在方法内、方法形参、代码块中、构造器形参、构造器内部的变量
2.3默认初始化值的情况：
属性：类的属性，根据其类型，都有默认初始化值
整型(byte,short,int,long) 0
浮点型(float,double) 0.0
字符型(char) 0(或\u0000)
布尔型(Boolean) false
引用数据类型(类、数组、接口)null
局部变量：没有默认初始化值
意味着，我们在调用局部变量之前，一定要显示赋值、
特别的： 形参在调用时，赋值即可
2.4在内存中加载的位置
属性：加载到堆空间中（非static）
局部变量：加载到栈空间中
//类和对象的使用
public static void main(String[] args) {
// 创建一个类的对象 = 类的实例化 =实例化类
//创建Perso类的对象
// 调用属性:对象.属性
Preson p1 =new Preson();
p1.name = "Tom";
p1.isMale = true;
System.out.println(p1.age);
//调用方法：对象。方法
p1.eat();
p1.sleep();
p1.talk("Chinese");
}
}
class Preson{
//属性
String name;
int age = 1;
boolean isMale;
//方法
public void eat(){
System.out.println("吃饭");
}
public void sleep(){
System.out.println("睡觉");
}
public void talk(String language){
System.out.println("交流"+language);
}
2.方法 = 成员方法 = method = 函数
- jdk 5.0新增的方法
*具体使用： - 1.可变个数形参的方法，数据类型…变量名
- 2.当调用可变个数形参的方法时，传入的个数可以是：0个，1个，2个
- 3.可变个数形参的方法与本类中的方法名相同，形参不同的方法之间构成了重载
- 4.可变个数形参的方法与本类中的方法名相同，形参类型也相同的数组之间,不构成重载，霍换句话说，二者不能共存
- 5.可变个数形参在方法的形参中，必须声明在末尾
- 6.可变个数形参在方法的形参中,只能声明一个可变形参
public class MethoedArgsTest {
public static void main(String[] args) {
MethoedArgsTest test = new MethoedArgsTest();
test.show(12);
test.show("hello");
test.show("AA","BB","CC");
test.show(new String[]{"AA","BB","CC"});
}
public void show(int i){
}
public void show(String s){
System.out.println("show(String)");
}
public void show(String ... strs){
System.out.println("show(String ... Strs)");
}
// public void show(String[] strs){
// System.out.println("666");
// }
public void show(int i,String ... strs){
System.out.println(i);
}
// 可变个数形参，必须声明在末尾
// public void show(int i,String ... strs,int b){
// System.out.println(i);
// }
}
方法形参的值传递机制：值传递
形参:方法定义时小括号里面声明的参数
实参：方法调用时，实际传递给形参的数据
值传递机制：
如果参数是基本数据类型，此时实参赋给形参的是实参真实存储的数据值 。
如果参数是引用数据类型，此时实参赋给形参的是实参真实存储的地址值。
方法 的重载 overload loading…
1.重载的概念：在同一个类中，允许存在一个以上的同名方法，只要他们的参数个数或者参数类型不同即可
“两同一不同”：同一个类、相同方法名
参数列表不同：参数个数不同，参数类型不同,参数顺序不同
2.举例：Array类中的sort()方法
3.判断是否是重载：
- 跟方法的权限修饰符，返回值类型，形参变量名，方法体都没有关系
4.在通过对象调用方法时，如何确定某一指定的方法；
- 方法名—>参数列表
3、构造器(或构造方法、constructor)的使用
一、构造器的使用：
- 1.创建对象
- 2.初始化对象的属性
二、说明：
- 1.如果没有显式的定义构造器类的话，则系统默认的空参的构造器
- 2.定义构造器的格式：权限修饰符 类名(形参列表){}
- 3.一个类中定义多个构造器，彼此间构成了重载
- 4.一旦我们显式的定义了构造器之后，系统就不会在提供默认的空参构造器
- 5.一个类中。至少会有一个构造器
- 6.构造方法只能在实例化的对象的时候被调用，new
public static void main(String[] args) {
//创建类的对象：new + 构造器
Person p = new Person();
p.eat();
}
}
class Person{
String name;
int age;
//构造器
public Person(){
System.out.println("Person()....");
}
public void eat(){
System.out.println("人吃饭");
}
4、类的成员之四：代码块(或初始化块)
-
1.作用：用来初始化类和对象
-
2.代码块如果有修饰的话，只能是static
-
3.分类：静态代码块 vs 非静态代码块
-
4.静态代码块
-
4.1可以有输出语句
-
4.2随着类的加载而执行，类只加载一次，所有只执行一次
-
4.3作用：初始化类的信息
-
4.4如果一个类中，定义了多个代码块，则按照执行顺序执行
-
4.5静态代码块的执行优先于非静态代码块的执行
-
4.6静态代码块内只能调用静态的属性、方法，不能调用非静态的属性、方法
-
5.非静态代码块
-
5.1可以有输出语句
-
5.2随着类的创建而执行，每创建一次对象，就执行一次
-
5.3作用：可以在创建对象时，对对象的属性进行初始化
-
5.4如果一个类中，定义了多个非静态代码块，则按照执行顺序执行
-
5.5非静态代码块内可以调用静态的属性、方法，也可以调用非静态的属性、方法
-
对属性可以初始化的位置：
-
①默认初始化
-
②显示初始化/⑤在代码块中赋值
-
③构造器初始化
-
④有了对象后，可以通过对象.属性 或 对象.方法的方式进行赋值
-
总结：由夫及子，静态先行
public class BlockTest {
public static void main(String[] args) {
String desc = Person.description;
System.out.println(desc);
String desc1 = Person.description;
Person p1 = new Person();
System.out.println(p1.age);
Person p2 = new Person();
}
}
class Person{
//属性
String name;
int age;
static String description = "我是一个人";
public Person(){
}
public Person(String name,int age, String description){
this.name = name;
this.age = age;
}
//非静态代码块
{
System.out.println("hello: bkock-2");
age = 1;
}
{
System.out.println("hello: bkock-1");
age = 1;
description = "我是一个爱学习的人";
info();
}
//静态代码块
static{
System.out.println("hello:static bkock-1");
description = "我是一个爱学习的人";
}
static{
System.out.println("hello:static bkock-2");
description = "我是一个爱学习的人";
}
//非静态代码块
{
System.out.println("hello: bkock");
age = 1;
}
//方法
public void eat(){
System.out.println("吃饭");
}
public static void info(){
System.out.println("我是一个快乐的人");
}
//构造器
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
}
5.类的内部成员之五：内部类
-
1.Java中允许将一个类A声明在另一个类B中，则类A就是内部类，类B就是外部类
-
2.内部类的成员：成员内部类 vs 局部内部类(方法，代码块，构造器)
-
3.成员内部类
-
一方面：作为外部类的成员
-
另一方面：作为类：可以定义属性、方法、构造器
-
可以被final修饰，表示此类不能被继承，言外之意，不用final就可以继承
可以被abstract修饰 -
4.关注如下3个问题
-
1.任何实例化成员内部类的对象
-
2.如何在成员内部类中区分调用外部类的结构
-
3.开发中局部内部类的使用
二、面向对象的三大特征：封装、继承、多态、（抽象性）
1.面向对象的特征一：封装与隐藏
-
当我们创建一个类的对象以后，我们可以通过"对象.属性的"方式，对对象的属性进行赋值，这里，赋值操作要受到数据类型和存储范围的制约。
-
概念 :隐藏具体的实现，提供对外的用户接口给用户调用
-
但是往往实际问题中，，我们需要给属性赋值，加入额外的条件，这个条件，不能在属性声明时体现，我们只能通过方法进行限制条件的添加。
-
同时，我们还要需要避免用户在使用"对象.属性"的方式对属性赋值。则需要将属性声明成(private)
-
—>此时，针对属性我们就有了封装性。
-
二、封装性的体现
-
- 我们将属性私有化(private)，同时，
-
提供公共的(public)方法来获取(getXXX)和设置(setXXX)
-
2.不对外暴露私有的方法
-
3.单例模式
-
- 三、封装性的体现，需要权限修饰符的配合
-
1.Java规定的四种权限：private、缺省、protected、public
-
2.4种权限可以用来修饰类及类 的内部结构：属性、方法、构造器、内部类
-
3.修饰类：只能用缺省，public
-
优点：复用性 安全性
-
get：有返回值无形参
-
set:没有返回值有形参
String name;
private int age ;
private int legs;//腿的个数
//提供get/set方法
2.面向对象的特征二：继承性
一、继承性的好处：
① 减少了代码的冗余，提高了代码的复用性
② 便于功能的扩展
③ 为之后的多态性，提供了前提
二、继承性的格式:class A extends B{}
A:子类 、派生类、subclass
B：父类、超类、基类、superclass
2.1体现：一旦子类A继承了父类B之后，子类就获取了父类B声明的结构：属性和方法
特别的，父类中声明为private的属性和方法，子类继承父类以后，任然认为获取了父类
只是因为封装性的影响，使子类不能直接的调用父类的结构而已。
2.2子类继承父类以后，还可以声明自己特有的属性和方法：实现功能的扩展。
子类和父类的关系，不同于子集和集合的关系。
extends:延展、扩展
三、Java中关于继承性的规定：
1.一个类可以被多个类继承
2.一个类只能有一个父类：单继承
3.子父类是一个相对的概念。(拥有直接父类和间接父类)
4.子类直接继承的父类,称为直接父类，间接继承的父类，称为：间接父类。
5子类继承了父类以后，就获取了直接父类和间接父类中声明的属性和方法。
四、1.如果我们没有显示声明一个类的父类的话，则此类继承于java.lang.Object类 。
2.所有的java类除(java.lang.Object类 之外)，都直接或间接继承于java.lang.Object类
3.意味着，所有的java类都具有java.lang.Object类中的所有功能。
Object是所有类的父类
public class Studens extends Person{
// String name;
// int age;
String major;
public Studens(){
}
public Studens (String name,int age){
this.name = name;
this.age = age;
}
public void eat(){
System.out.println("吃饭");
}
public void sleep(){
System.out.println("睡觉");
}
public void study(){
System.out.println("学习");
}
}
重写
方法的重写:在子类可以根据需要对从父类中继承来的方法进行改造，也成为方法的重置和覆盖。overwrite/override
1.重写：子类继承父类后，可以对父类中同名同参数的方法，进行覆盖操作。
2.应用：重写以后，当创建子类对象以后，通过子类调用子父类中的同名同参数的方法时，实际执行的就是子类重写父类的方法。
3.重写是规定：
方法的声明：权限修饰符 返回值类型 方法名 (参数类型) throws 异常的类型{
方法体 }
约定俗称：子类中的叫重写方法，父类中 的叫被重写方法
- ① 子类重写的方法的方法名和形参列表与父类被重写的方法的方法名和形参列表相同。
- ② 子类重写的方法的权限修饰符不小于父类被重写的方法的权限修饰符。
- 特殊情况：子类不能重写父类中声明为private的
- ③ 返回值类型：
- 父类被重写的方法的返回值类型是void，那么则子类重写的方法的返回值也只能是void
- 父类被重写的方法的返回值类型是A类型，那么则子类重写的方法的返回值类型可以是A类或A类的子类
- 父类被重写的方法的返回值类型是基本数据类型(比如：double)，
- 那么则子类重写的方法的返回值类型也必须是相同的基本数据类型(必须也是double)
- ④ 子类重写的方法抛出的异常类型不大于父类被重写的方法抛出的异常类型。
- 子类和父类中的同名同参数的方法要么是为非static的(考虑重写)，要么都声明为static的(不是重写)。
- 静态方法不能被覆盖，是随着类的加载而加载的
面试题： - 区分方法的重载和重写
3.面向对象特征之三：多态性
1.理解多态性：可以理解为一个事物的多种形态
2.何为多态性：对象的多态性：父类的引用指向子类的对象(或子类的对象赋给父类的引用)
3.多态的使用：虚拟方法调用
子类中定义了一父类同名同参数的方法，在多态的情况下，讲此父类的方法称为虚拟方法，父类根据赋给它的不同的 子类对象，调用属于子类的该方法。这样的方法调用在编译期是无法确定的。—动态绑定
有了对象的多态性后，我们在编译期，只能调用父类中声明的方法，但在解释运行期执行的是子类重写父类的方法。
总结：编译看左边，运行看右边
4.多态性的使用前提:
①要有类的继承关系
②要有方法的重写
5.对象的多态性只适用于方法，不适用于属性。
多态性是编译时行为还是运行时行为–>运行时
public class PersonTest {
public static void main(String[] args) {
Person p1 = new Person();
p1.eat();
Man man = new Man();
man.eat();
man.age = 25;
man.earnMoney();
//*******************************
System.out.println("*****************");
//对象的多态性：父类的引用指向子类的对象
Person p2 = new Man();
//多态性的使用：当调用父类同名同参数 的方法时，实际执行的是子类重写父类的方法 --虚拟方法调用
p2.eat();
p2.walk();
}
}
三、其他关键字：this，super,abstract，interface,static,final,package,import
1.this关键字的使用
1.可以用来修饰属性、方法、构造器
2.this修饰属性和方法
this理解为：当前对象
2.1在类的方法或构造器中，我们都可以使用"this.属性,this.方法"的方式,调用当前的方法或属性，但是，通常情况下，我们都会选择忽略this，特殊情况下，如果方法的形参和类的属性同名时，我们必须显式的使用，“this.属性”，表明此变量时属性，而非形参
3.this调用构造器
① 我们在类的构造器中，可以显式的使用(this形参列表)的方式，调用本类中指定的其他构造器
② 构造器中不能通过"this(形参列表)“的方式调用自己
③如果一个类中有n个构造器，则最多有n-1构造器中使用了"this(形参列表)”
④ 规定：this(形参列表) 必须 声明在当前构造器的首行
⑤ 构造器内部，最多只能声明一个this(形参列表)的方式
2.super关键字的使用：
1.super的理解:父类的
2.super可以用来调用属性、方法、构造器
3.super的使用
3.1我们可以在子类的方法和构造器中，通过"super.属性"和"super.方法"的方式，显式的调用父类中声明的属性和方法，但是，我们通常情况下，习惯的省略"super."
3.2特殊情况：当子类和父类定义了同名的属性时，我们想要在子类中调用父类中声明的属性，则必须显式使用"super.属性"的方式，表示调用的是父类中声明的属性。
3.3特殊情况：当子类重写了父类的方法时，我们想在子类的方法 中调用父类中被重写的方法时，则必须显式的使用"super.方法"的方式，表示调用的时父类中被重写的方法。
4.super调用构造器
- 4.1我们可以在子类的构造器中使用"super(形参列表)"的方式，调用父类中声明的指定的构造器
- 4.2使用"super(形参列表)"的使用，必须声明在子类构造器的首行。
- 4.3在类的构造器中，针对于super(形参列表)和this(形参列表)只能二选一，不能同时出现
- 4.4当我们在构造器的首行即没有super(形参列表)也没有this(形参列表)—没有显式声明，
- 则默认调用的是super父类默认空参构造器:super()
3.abstract关键字的使用
1.abstract：抽象的
可以用来修饰的结构：类，方法，类一旦被抽象，就不能被实例化
抽象类中一定有构造器，便于子类实例化时调用
开发中都会提供抽象类的子类，让子类实例化，完成相关操作
抽象方法：只有方法的声明，没有方法体
包含抽象方法的类，一定时抽象类，反之，抽象类可以没有抽象方法
注意点：不能用来修饰属性，构造器，代码块等结构
- 不能用来修饰私有方法、静态方法、final的方法、final的类
- 静态方法不能被重写
4.interface的使用
1.接口使用interface来定义
2.java中，类和接口是并列的两个结构
3.如何定义接口:定义接口中的成员
3.1JDK7及以前：只能定义全局常量和抽象
方法
全局常量：public static final的,但是书写时可以不写
抽象方法：public abstract的
3.2JDK8：出来可以定义全局常量和抽象方法外，还可以定义静态方法，默认方法
4.接口中，不能定义构造器！意味着接口不可以实例化
5.java开发中，接口都通过类去实现(implements)去使用
- 如果实现类覆盖了接口中的所有抽象方法，则此实现类就可以实例化
- 如果实现类没有覆盖了接口中的所有抽象方法，则此实现类任为一个抽象类
6.Java中可以实现多接口---->弥补ljava的单继承的局限性
- 格式：class extends BB implements 接口A，接口B
7.接口与接口之间可以多继承
- 8.接口的具体实现，体现了多态性
- 9.接口，实际上可以看做一种规范
jdk8新规范
- ①接口中定义的静态方法，只能通过接口来调用
- ②通过实现类的对象，可以调用接口中的默认方法
- 如果实现类重写了接口中的默认方法，调用时，任然调用的是重写后的方法
- ③类优先原则
面试题：抽象类与接口有哪些异同？ - 相同：都不能实例化，都有抽象方法
- 不同：抽象类有构造器，接口没有构造器，接口多继承，多实现
5.static关键字的使用
1.static：静态的
2.static可以用来修饰类的结构(属性，方法，代码块，内部类)
3.使用static来修饰属性：
随着类的加载而加载，通过类.属性的方式来调用
只会加载一次，存在方法区的静态域中
4.使用static来修饰方法：静态方法
随着类的加载而加载 可以通过类.静态方法调用
静态方法只能调用静态方法, 非静态方法可以调用类中的所有方法
5.在静态中不能使用this和super，关于静态方法和非静态方法的使用，可以从生命周期的角度去理解
6.开发中，如何确定一个属性是否要声明为static,属性是可以被共享的，不会随着对象的不同而不同
6.final的使用
final：最终的
- 1.final可以用来修饰的结构:类、属性、方法
- 2.修饰类：此类则不能被其他类所继承
- 3.修饰方法：不能被重写，可以被重载
- 4.修饰变量：此时就是常量，
- 5.修饰属性：可以考虑初始化位置：显示初始化，代码块，构造器
- 修饰局部变量：形参
- static final：用来修饰属性：全局常量
7.package关键字的使用
- 1.为了更好的实现项目中类的管理，提供包的管理
- 2.使用package声明类或者接口所属的包，声明在源文件的首行
- 3.包，属于标识符，遵循标识符的命名规则、规范、见名知意
- 4.每"."一次，就代表一层文件目录
- 补充：同一个包下 ，不能命名同名的的类和接口
- 不同的包下，可以命名同名的类和接口
import关键字的使用
- import：导入
- 1.在源文件中显式的使用import导入指定包下的类、接口
- 2.声明在包的声明和类的声明中间
- 3.如果需要导入多个结构，则并列写出即可
- 4.可以使用"xxx.*"的方式表示可以导入xxx包下的所有结构
- 5.如果使用的类和接口时Java.lang包下的，则可以省略import结构
- 6.如果使用的类、接口时本包下定义的，则也可以省略import结构
- 7.在源文件中，使用了不同包下的同名的类， 则必须至少有一个类需要以全类名的方式显式
- 8.使用"xxx.*"的方式表示可以导入xxx包下的所有结构，
- 但是如果使用的是xxx下的子包下的结构，则任需要显式导入
异常的处理：抓抛模型
过程一、“抛”：程序在正常执行过程中，一旦出现异常，就会在异常代码处生成一个对应异常类的对象并抛出此对象， 一旦抛出对象后，后面的代码就不会在执行
过程二、“抓”：可以理解为处理异常的方式：①try-catch-finally ② throws
关于异常的对象的产生：①系统自动生成的异常对象
②手动的生成一个异常对象，并抛出(throw)
在方法 内：throw new Exception();
异常处理二、throws + 异常类型 写在方法的声明处，指名此方法声明时，可能抛出异常类型
方法重写的规则：
子类重写的抛出异常类型不能大于父类被重写的方法抛出的异常类型
3.开发中如何选择使用try-catch-finally 和 throws
- 3.1如果父类中被重写的方法没有使用throws，则子类重写的方法也不能使用
- 3.2执行的方法中，先后有调用了几个方法，这几个方法时递进关系执行的，可以使用throws
4.如何自定义异常类？
- 1.继承于现有的异常结构：RuntimeException 、Exception
- 2.提供全局常量:seriaVersionUID
- 3.提供重载的构造器
递归方法的使用(了解)
- 1.递归方法：一个方法体内调用它的自身
- 2.方法递归包含了一种隐式的循环，他会重复每一段代码，但这种重复执行无需循环控制
- 递归一定是已知的方向递归，否则这种循环就变成了无限递归
抽象类的应用：模板方法的设计模式
public class TemplateTest {
public static void main(String[] args) {
Template t = new SubTemplate();
t.spendTime();
}
}
abstract class Template{
//用来计算某段代码执行所花费的时间
public void spendTime(){
long start = System.currentTimeMillis();
this.code();
long end = System.currentTimeMillis();
System.err.println("花费的实际" + (end - start));
}
public abstract void code();
}
class SubTemplate extends Template{
@Override
public void code() {
for (int i = 2; i < 1000; i++) {
boolean isFlag = true;
for (int j = 2; j < Math.sqrt(i); j++) {
if (i % j == 0) {
isFlag = false;
break;
}
}
if (isFlag) {
System.out.println(i);
}
}
}
}
接口应用：代理模式
public class NetWorkTest {
public static void main(String[] args) {
Server server = new Server();
ProxyServer proxyServer = new ProxyServer(server);
proxyServer.browse();
}
}
interface NetWork {
public void browse();
}
class Server implements NetWork{
@Override
public void browse() {
System.out.println("真实服务器访问网络");
}
}
class ProxyServer implements NetWork{
private NetWork work;
public ProxyServer(NetWork work){
this.work = work;
}
public void check(){
System.out.println("联网之前的检查工作");
}
@Override
public void browse() {
check();
work.browse();
}
}
1.如何实现向下转型，需要注意什么问题？如何解决该问题？
使用强转符()
Person p = (Person) new Man();
异常：classCastException异常，程序终止执行。
使用instanceof判断，在使用向下转型前进行判断。
2.==和equals()有何区别
1）对于==，如果作用于基本数据类型的变量，则直接比较其存储的 “值”是否相等；
如果作用于引用类型的变量，则比较的是所指向的对象的地址
2）对于equals方法，注意：equals方法不能作用于基本数据类型的变量
如果没有对equals方法进行重写，则比较的是引用类型的变量所指向的对象的地址；
诸如String、Date等类对equals方法进行了重写的话，比较的是所指向的对象的内容。
3.基本数据类型，包装类，String类三者之间的相互转换
- 自动拆箱和自动装箱
- 包装类–》基本数据类型：调用包装类的xxxValue()
- String类----->基本数据类型，包装类:调用包装类的parseXxx(String s)；
- 基本数据类型，包装类----->String类:调用string重载的Val ueOf(Xxx xxx)；
单例设计模式：就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例
区分 饿汉式 和 懒汉式
饿汉式 ：一开始就造好了对象，加载时间过长，线程安全
懒汉式：延迟对象的创建，目前的写法线程不安全
public class SingletonTest {
public static void main(String[] args) {
Bank bank1 = Bank.getInstance();
Bank bank2 = Bank.getInstance();
System.out.println(bank1 == bank2);
}
}
//饿汉式
class Bank{
//1.私有化类的构造器 ,不让外界调用对象
private Bank(){
super();
}
//2.内部创建类的对象
// 4.要求此对象也要为静态的
private static Bank instance = new Bank();
// 3.提供公共的静态方法，返回类的对象
public static Bank getInstance(){
return instance;
}
}
单例模式懒汉式
public class Singleton1 {
public static void main(String[] args) {
Order order1 = Order.getInstace();
Order order2 = Order.getInstace();
System.err.println(order1 == order2);
}
}
//单例模式懒汉式
class Order{
//1.私有化类的构造器
private Order(){
}
// 2.声明当前类的对象,没有初始化
// 4.此对象也要声明为静态的
private static Order instance = null;
// 3.声明public，static的返回当前类的对象的方法
public static Order getInstace(){
if (instance == null) {
instance = new Order();
}
return instance;
}
}
java中的JUnit单元测试
1.选中当前工程 – 右键选择 build path – add libraries --JUnit 4 --下一步
2.创建一个jiava类，进行单元测试
此时java类的要求：①此类是公共的 ②要提供一个公共的无参的构造器
3.在此类中去声明单元测试方法,此时单元测试的方法：方法的权限是public ，没有返回值类型，没有形参
4.此单元测试方法上，需要声明注解@Test,并在单元测试类中，导入import.org.junit.Test
5.声明好单元测试方法以后，就可以在 方法体内测试相应的代码
6.写完代码后，左键双击方法名，右键run as — JUnit 4
说明：1.如果执行没有异常就会显现：绿条
2.当执行结果出现异常就会显示：红条
Object类
1.Object类是所有Java类的根父类
2. 如果在类的声明中未使用extends关键字指明其父类，则默认为父类Object类
3.Object类中的功能（属性，方法)就具有通用性
4.Object类有一个空参构造器
Object类中toString()的使用
1.当我们输出一个对象的引用时，调用的是当前对象的toString()
2.Object类中的tostring()的定义
3.像string，data，file，包装类都重写了Object类中的toString()方法,使得在调用对象的同String时，返回“实体内容信息”;
4.自定义类也可以重写toString方法，调用时，返回对象的"实体内容"
包装类的使用
1.java提供了8中基数据类型的包装类，使得基本数据类型 的变量具有类的特征
2.掌握：基本数据类型，包装类，String类三者之间的相互转换
Integer内部定义了IntegerCaChe结构，IntegerCache中定义了Integer[]
保存了-128~127范围内的整数，如果我们使用自动装箱方式，给Integet赋值的范围在
-128~127范围内时，可以直接使用数组中的元素，不用再去new了。目的：提高效率
String类----->基本数据类型，包装类:调用包装类的parseXxx(String s)；
// 方式1
String str1 = "123";
int parseInt = Integer.parseInt(str1);
System.out.println(parseInt + 1);
基本数据类型，包装类----->String类:调用string重载的ValueOf(Xxx xxx)；
// 方式1
int num1 = 10;
String str1 = num1 + "";
// 方式二
float f = 10.0f;
String str2 = String.valueOf(f);
System.out.println(str2);
包装类–>基本数据类型：调用包装类的xxxValue()
Integer in1 = new Integer(12);
int intValue = in1.intValue();
System.out.println(intValue + 1);
Float f1 = new Float(12.0);
f1.floatValue();
基本数据类型—》包装类，调用包装类的构造器
int num1 = 10;
Integer in1 = new Integer(num1);
System.out.println(in1.toString());
Integer in2 = new Integer("123");
System.out.println(in2.toString());
Integer in3 = new Integer("123");
System.out.println(in3.toString());
JDK5.0 新特性 ：自动拆箱和自动装箱
// 自动装箱:
int num = 10;
Integer in1 = num;
boolean b1 = true;
Boolean b2 = b1;
// 自动拆箱
System.err.println(in1.toString());
int num3 = in1;
