java面向对象

会像玫瑰和亚里士多德一样死去？

已于 2022-03-01 21:45:32 修改

阅读量349

点赞数

文章标签： java 开发语言后端

于 2022-01-23 12:56:06 首次发布

本文链接：https://blog.csdn.net/m0_63226521/article/details/122647525

版权

什么是面向对象

面向对象与面向过程(理解)

1.面向过程:强调的是功能行为，以函数为最小单位，考虑怎么做
2.面向对象:强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。

两个重要概念（类与对象）

1.类：对一类事物的描述，是抽象的，概念上的定义。在Java语言范畴中，我们将功能、结构等封装到类中，通过类的实例化，来调用具体的功能结构
2.对象：是实际存在的该类事物的每个个体，也称为实例

类和对象的使用（面向对象思想落地的实现）

创建类，设计类的成员
创建类的对象
通过 “ 对象 . 属性”或"对象 . 方法“调用对象的结构
如果创建了一个类的多个对象，则每个对象都独立拥有一套类的属性（非static）
意味着：如果修改一个对象的属性a，则不影响另外一个对象属性a的值
堆：存放对象实例
栈：指虚拟机栈，存储局部变量
方法区：存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据

JVM内存结构与对象内存解析

编译完源代码以后，生成一个或多个字节码文件。
我们使用JVM中的类的加载器和解释器对生成的字节码文件进行解释运行。
意味着，需要将字节码文件对应的类加载到内存中，涉及到内存解析。

Java类及类的成员

属性（成员变量）vs局部变量

相同点：
①定义变量的格式：数据类型变量名 =变量值
②先声明，后使用
③变量都有其对应的作用域
不同点：
① 在类中声明的位置不同：
属性 (成员变量）：直接定义在类的一对{ }中
局部变量：声明在方法内，方法形参，代码块内，构造器形参，构造器内部的变量

②关于权限修饰符的不同
属性：可以在声明属性时，指明其权限，使用权限修饰符
常用的权限修饰符：private,public，缺省，protected
局部变量：不可以使用权限修饰符
③默认初始化值的情况
属性：类的属性，根据其类型，都有默认初始化值
整型(byte,short,int,long)：0
浮点型(float,double)：0.0
字符型(char)：0（或’\u0000’)
布尔型(boolean):false
引用数据类型（类，数组，接口）：null
局部变量：没有默认初始化值
调用局部变量之前，一定要显式赋值；
特别的：形参在调用时，我们赋值即可
④在内存中加载的位置
属性：加载到堆空间
局部变量：加载到栈空间

方法

描述类该有的功能

方法的使用中，可以调用当前类的属性或方法
特殊的：方法A中又调用了方法A : 递归方法（自带循环）
方法中，不可以定义方法

权限修饰符 （static） 方法返回值类型 方法名称([参数类型 参数名, ...]){
	方法体代码;
	...
	[return 返回值;]
}
[]()中的看具体情况

形参列表

位置：方法名称后括号中

方法可以声明一个或多个形参

返回值

如果方法有返回值，则必须在方法声明时，指定返回值的类型，同时，方法中，需要使用return关键字来返回指定类型的变量或常量。
return将某一状态返回到调用其所在函数的地方
如果方法没有返回值，则在方法声明时，使用void来表示，通常不使用return;
如果使用的话，只能用“return" , 表示结束此方法。
（return后不声明执行语句）
匿名对象
1.理解：我们创建的对象，没有显式的赋给一个变量名
2.特征：匿名变量只能调用一次

new Phone().sendEmail();

每new一次就会造一个对象

重载

两同一不同
两同：同一个类，相同方法名
一不同：参数列表不同，即参数个数不同，参数类型不同

判断是否构成重载：
跟方法的权限修饰符，返回值类型，形参变量名，方法体无关
在通过对象调用方法时，如何确定某一个指定的方法：
方法名--------->参数列表

在这里插入图片描述

重写

子类继承父类以后，可以对父类中同名同参数的方法，进行覆盖操作
重写以后，当创建子类对象以后，通过子类对象调用父类中的同名同参数后，
实际上执行的是子类重写父类的方法
①子类中的叫重写的方法，父类中的叫被重写的方法
②子类重写的方法名和形参列表与父类被重写的方法名和形参列表相同
③子类重写的方法的权限修饰符不小于父类被重写的方法的权限修饰符
特殊的：子类不能重写父类中声明为private权限的方法
④返回值类型

父类被重写的方法返回值类型是void,则子类重写的方法返回值类型只能是void
父类被重写的方法返回值类型是A,则子类重写的方法返回值类型是A类或A的子类
父类被重写的方法返回值类型是基本数据类型，则子类重写的方法返回值类型与它相同
⑤子类重写的方法抛出的异常类型不大于父类被重写的方法抛出的异常类型
⑥子类和父类同名同参数的方法要么都声明为static(不考虑重写），要么都声明为非static(考虑重写）

关于变量的赋值

如果变量是基本数据类型，此时赋值的是变量所保存的数据值
如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值
引用数据类型变量只可能储存两类值，null或地址值

方法形参的传递机制

形参：方法定义时，声明的小括号内的参数
实参：方法调用时，实际传递给形参的数据
值传递机制：
①如果参数是基本数据类型，此时实参赋给形参的是实参真实存储的数据
②如果参数是引用数据类型，此时实参赋给形参的是实参真实存储数据的地址值（含变量的数据类型）

构造器

作用：
①创建对象
②初始化对象的属性
说明:
①如果没有显式的定义类的构造器的话，则系统默认提供一个空参的构造器
②定义构造器的格式：权限修饰符类名(形参列表) { }
③一个类中定义的多个构造器，彼此构成重载
④一旦我们显式的定义了类的构造器之后，系统就不再提供默认的空参构造器
⑤一个类中，至少有一个构造器
属性赋值的先后顺序：
1.默认初始化
2.显式初始化
3.构造器中初始化（赋值）
4.通过“对象.方法”或“对象.属性”的方式，赋值

代码块

由于代码块并没有具体的名，所以不能主动调用。
只能通过类(静态代码块)的加载或对象的创建（非静态代码块）来调用

1．代码块的作用:用来初始化类、对象
2．代码块如果有修饰的话，只能使用static.
3．分类:静态代码块vs非静态代码块
4．静态代码块

内部可以有输出语句
随着类的加载而执行,而且只执行一次
作用:初始化类的信息
如果一个类中定义了多个静态代码块，则按照声明的先后顺序执行
静态代码块的执行要优先于非静态代码块的执行
静态代码块内只能调用静态的属性、静态的方法，不能调用非静态的结构

static{

}

5．非静态代码块

内部可以有输出语句
随着对象的创建而执行
每创建一个对象，就执行一次非静态代码块
作用:可以在创建对象时，对对象的属性等进行初始化
如果一个类中定义了多个非静态代码块，则按照声明的先后顺序执行
非静态代码块内可以调用静态的属性、静态的方法，或非静态的属性、非静态的方法

{

}

ps：
对属性可以赋值的位置：
①默认初始化
②显式初始化
③构造器中初始化
④有了对象以后，可以通过"对象.属性"或"对象.方法"的方式，进行赋值
⑤在代码块中赋值
由父及子，静态先行
父类静态代码块–>子类静态代码块–>父类非静态代码块、构造器–>子类非静态代码块、构造器
执行的先后顺序:① -② / ⑤ -③-④

内部类

当一个事务的内部，还有一个部分需要一个完整的结构进行描述，而这个内部的完整的结构又只能为外部事物提供服务，那么整个内部的完整结构最好使用内部类。

Java中允许将一个类A声明在另一个类B中，则类A就是内部类，类B称为外部类
内部类的分类：成员内部类（静态、非静态） vs 局部内部类(方法内、代码块内、构造器内)

成员内部类：
一方面，作为外部类的成员：
>调用外部类的结构
>可以被static修饰
>可以被4种不同的权限修饰

 另一方面，作为一个类：
 	> 类内可以定义属性、方法、构造器等
 	> 可以被final修饰，表示此类不能被继承。言外之意，不使用final，就可以被继承
 	> 可以被abstract修饰

关注如下的3个问题
4.1 如何实例化成员内部类的对象
4.2 如何在成员内部类中区分调用外部类的结构
4.3 开发中局部内部类的使用

 public class InnerClassTest {
	public static void main(String[] args) {
		
		//创建Dog实例(静态的成员内部类):
		Person.Dog dog = new Person.Dog();
		dog.show();
		//创建Bird实例(非静态的成员内部类):
//		Person.Bird bird = new Person.Bird();//错误的
		Person p = new Person();
		Person.Bird bird = p.new Bird();//非静态只能通过对象来调用
		bird.sing();
		
		System.out.println();
		
		bird.display("黄鹂");
		
	}
}


class Person{
	
	String name = "小明";
	int age;
	
	public void eat(){
		System.out.println("人：吃饭");
	}
	
	
	//静态成员内部类
	static class Dog{
		String name;
		int age;
		
		public void show(){
			System.out.println("卡拉是条狗");
//			eat();
		}
		
	}
	//非静态成员内部类
	class Bird{
		String name = "杜鹃";
		
		public Bird(){
			
		}
		
		public void sing(){
			System.out.println("我是一只小小鸟");
			Person.this.eat();//调用外部类的非静态属性
			eat();
			System.out.println(age);
		}
		
		public void display(String name){
			System.out.println(name);//方法的形参
			System.out.println(this.name);//内部类的属性
			System.out.println(Person.this.name);//外部类的属性
		}
	}

在方法中定义的局部内部类，如果调用方法中的局部变量，要求此局部变量声明为final的
在这里插入图片描述

面向对象的三大特征

一、封装性

使用者对类内部定义的属性(对象的成员变量)的直接操作会导致数据的错误、混乱或安全性问题。在面向对象程式设计方法中，封装（英语：Encapsulation）是指一种将抽象性函式接口的实现细节部份包装、隐藏起来的方法。

封装是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。封装可以被认为是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问。要访问该类的代码和数据，必须通过严格的接口控制。

封装最主要的功能在于我们能修改自己的实现代码，而不用修改那些调用我们代码的程序片段。

封装原则：将不需要对外提供的内容都隐藏起来，把属性都隐藏，提供公共方法对其访问。
好处

通过隐藏对象的属性来保护对象内部的状态（隐藏信息、实现细节）。
提高了代码的可用性和可维护性，因为对象的行为可以被单独的改变或者是扩展（将变化隔离，类内部的结构可以自由修改，增加内部实现部分的可替换性）。
禁止对象之间的不良交互提高模块化（良好的封装能够减少耦合）。
可以对成员变量进行更精确的控制。
容易保证类内部数据间的一致性，从而提高软件的可靠性。
封装性的体现，需要权限修饰符来配合

二、继承（extends）

好处：
①减少了代码的冗余，提高了代码的复用性
②便于功能的扩展
③为之后多态性的使用，提供了前提

继承的格式：class A extends B{}
A:子类、派生类、subclass
B:父类、超类、基类、superclass

①一旦子类A继承父类B以后，子类A中就获取了父类B中声明的所有属性和方法。
特别的，父类中声明为private的属性或方法，子类继承以后，仍然获得了父类中私有的结构。只是由于封装性的影响，使得子类不能直接调用父类的结构而已。
②子类继承父类以后，还可以声明自己特有的属性或方法：实现功能的拓展。子类和子类的关系，不同于子集和几何的关系。

规定：
①一个类可以被多个子类继承
②Java中类的单继承性：一个类只能有一个父类
③子父类是相对的概念
④子类直接继承的父类称为：直接父类，间接继承的父类为：间接父类
⑤子类继承父类后，就获取了直接父类及所有间接父类的属性和方法

继承体现的是一种"is a"的关系:如果A是B的一种或者B是A的一种,这个可以使用继承!

① 如果我们没有显式的声明一个类的父类的话，则此类继承于java.lang.Object类
②所有的java类（除java.lang.Object类之外）都直接或间接的继承于java.lang.Object类
③意味着，所有的java类具有java.lang.Object类声明的功能。
java.lang.Object类

Object类是所有Java类的根父类
如果在类的声明中未使用extends关键字指明其父类，则默认父类为java.lang.Object类
Object类中的功能(属性、方法)就具有通用性。
属性：无
方法：equals() / toString() / getClass() /hashCode() / clone() / finalize() / wait() / notify() / notifyAll()
Object类只声明了一个空参的构造器

四种访问权限修饰符

修饰符	类内部	同一个包	不同包的子类	同一个工程
private	yes
（缺省）	yes	yes
protected	yes	yes	yes
public	yes	yes	yes	yes

四种权限都可以用来修饰类及类的内部结构:
①4种权限都可以用来修饰类的内部结构：属性，方法，构造器，内部类
②修饰类，只能使用：缺省，public
在这里插入图片描述

三、多态性

理解：一个事物的多种形态
何为多态性：
其实是，对象的多态性：父类的引用指向子类的对象 ( 或子类的对象赋给父类的引用）
例： Person p2=new Man();
使用前提：①类的继承关系 ②方法的重写
Java实现多态，三个必要条件：继承、重写、向上转型
多态的使用，虚拟方法调用
有了对象的多态性后，在编译期，只能调用父类中声明的方法，但在运行期，实际执行的是子类重写父类的方法
总结：编译，看左边；运行，看右边
有了对象的多态性后，内存中实际上是加载了子类特有的属性和方法的，但是由于变量声明为父类类型，导致编译时，只能调用父类中声明的属性和方法，不能调用子类所特有的方法、属性
对象的多态性：只适用于方法，不适用于属性(编译和运行都看左边）
多态是编译时行为还是运行时行为：运行时行为
向下转型：将父类的引用强制转换子类的引用
instanceof
用来判定左边的引用类型是否与右边的引用类型的类型是否相同，
或左边引用类型是右边引用类型的子类或实现类( 右边引用类型可以是类、抽象类、接口）
为了避免向下转型时出现异常，在向下转型之前，先进行instanceof 的判断，
一旦返回true,就进行向下转型；返回false,不进行向下转型

引用 instanceof 类型
例： if(p2 instanceof Woman)
{
Woman w1=(Woman)p2;
w1.shopping();
System.out.println("***********Woman************");
}
若类B是类A的父类，a instanceof A 返回 true,则a instanceof B 也返回 true

接口

接口使用interface来定义
Java中，接口和类是并列的两个结构
如何定义接口：定义接口中的成员
①DK7及以前：只能定义全局常量和抽象方法
>全局常量：public static final的.但是书写时，可以省略不写
>抽象方法：public abstract的
②JDK8：除了定义全局常量和抽象方法之外，还可以定义静态方法、默认方法（略）
接口中不能定义构造器的！意味着接口不可以实例化
Java开发中，接口通过让类去实现(implements)的方式来使用.
如果实现类覆盖了接口中的所有抽象方法，则此实现类就可以实例化
如果实现类没有覆盖接口中所有的抽象方法，则此实现类仍为一个抽象类
Java类可以实现多个接口 —>弥补了Java单继承性的局限性
格式：class AA extends BB implements CC,DD,EE
接口与接口之间可以继承，而且可以多继承
接口的具体使用，体现多态性
接口，实际上可以看做是一种规范

所有的数据域均用 public static final 修饰，所有的
方法都用 public abstract 修饰，所以修饰符是可以省略的。

知识点1.接口中的静态方法，只能通过接口来调用
知识点2.通过实现类的对象，可以调用接口中的默认方法
如果实现类重写了接口中的默认方法，调用时，仍然调用的是重写以后的方法
知识点3：如果子类(或实现类)继承的父类和接口中声明了同名同参数的默认方法，那么子类在没有重写此方法的情况下，默认调用的是父类中同名同参数的方法–>类优先原则
知识点4：如果实现类实现了多个接口，而这多个接口中定义了同名同参数的默认方法，那么在实现类没有重写此方法的情况下，报错–>接口冲突
这就需要我们必须在实现类中重写此方法
知识点5.如何在子类(或实现类)的方法中调用父类，接口中被重写的方法

 public void myMethod() {
     method3();//调用自己定义的重写方法
     super.method3();//调用的是父类中声明的
     //调用接口中的默认方法
     CompareA.super.method3();//接口.
     CompareB.super.method3();
   }

接口是否能继承接口？
能
抽象类是否能实现（implements）接口？
能
抽象类是否能继承非抽象的类？
能

一个类只能extends一个父类，但可以implements多个接口。
一个接口则可以同时extends多个接口，却不能implements任何接口。
===>>Java中的接口是支持多继承的。

其他关键字

this关键字

this可以用来修饰、调用：属性、方法、构造器
this修饰属性和方法：
this理解为：当前对象或当前正在创建的对象
① 在类的方法中，我们可以使用"this.属性"或"this.方法"的方式，调用当前对象属性或方法。但是，通常情况下，我们都选择省略"this."。
特殊情况下，如果方法的形参和类的属性同名时，我们必须显式的使用"this.变量"的方式，表明此变量是属性，而非形参。
②在类的构造器中，我们可以使用"this.属性"或"this.方法"的方式，调用当前正在创建的对象属性或方法。但是，通常情况下，我们都选择省略"this."。特殊情况下，如果构造器的形参和类的属性同名时，我们必须显式的使用"this.变量"的方式，表明此变量是属性，而非形参。
this调用构造器
① 我们在类的构造器中，可以显式的使用"this(形参列表)"方式，调用本类中指定的其他构造器
② 构造器中不能通过"this(形参列表)“方式调用自己
③ 如果一个类中有n个构造器，则最多有 n - 1构造器中使用了"this(形参列表)”
④ 规定："this(形参列表)“必须声明在当前构造器的首行（规定）
⑤ 构造器内部，最多只能声明一个"this(形参列表)”，用来调用其他的构造器

super关键字

super理解为：父类的
super可以用来调用：属性、方法、构造器
①在子类的方法或构造器中，可以通过使用“super.属性”或“super.方法”，显式的调用父类中声明的属性或方法。通常省去“super."
②特殊的：当子类和父类定义了同名的属性时，要想在子类中调用父类中声明的属性，必须使用"super.属性"
③特殊的：当子类重写了父类的方法后，想在子类的方法中调用父类中被重写的方法，必须使用"super.方法"
super调用构造器
①可以在子类的构造器中显示的使用“super(形参列表）”的方式，调用父类中声明的指定的构造器
②“super(形参列表）”的使用，必须声明在子类构造器的首行
③在类的构造器中，“super(形参列表）”或“this(形参列表）”只能二选一，不能同时出现（因为两者都要求在首行）
④在类的构造器的首行，没有显式声明“super(形参列表）”或“this(形参列表）”，
则默认调用的是父类中空参的构造器：super( )。
( 没有写“super(形参列表）”或“this(形参列表）”，则调用默认的父类的super( ) ）
⑤在子类的多个构造器中，至少有一个类的构造器中使用了“super(形参列表）”，调用父类的构造器

package关键字

package关键字的使用

为了更好的实现项目中类的管理，提供包的概念
使用package声明类或接口所属的包，声明在源文件的首行
包，属于标识符，遵循标识符的命名规则、规范(xxxyyyzzz)、“见名知意”
每"."一次，就代表一层文件目录。

补充：同一个包下，不能命名同名的接口、类。
不同的包下，可以命名同名的接口、类。

import关键字

import关键字的使用
import:导入

在源文件中显式的使用import结构导入指定包下的类、接口
声明在包的声明和类的声明之间
如果需要导入多个结构，则并列写出即可
可以使用"xxx.*"的方式，表示可以导入xxx包下的所有结构
如果使用的类或接口是java.lang包下定义的，则可以省略import结构
如果使用的类或接口是本包下定义的，则可以省略import结构
如果在源文件中，使用了不同包下的同名的类，则必须至少有一个类需要以全类名的方式显示。
使用"xxx.*"方式表明可以调用xxx包下的所有结构。但是如果使用的是xxx子包下的结构，则仍需要显式导入
import static:导入指定类或接口中的静态结构:属性或方法。

static关键字

当我们编写一个类时，其实就是在描述其对象的属性和行为,而并没有产生实质上的对象。只有通过new关键字才会产生出对象，这时系统才会分配内存空间给对象,其方法才可以供外部调用。我们有时候希望无论是否产生了对象或无论产生了多少对象的情况下，某些特定的数据在内存空间里只有一份。例如所有的中国人都有个国家名称。每一个中国人都共享这个国家名称。不必在每一个中国人的实例对象中都单独分配一个用于代表国家名称的变量。

在这里插入图片描述

static:静态的

static可以用来修饰:属性、方法、代码块、内部类
使用static修饰属性:静态变量（或类变量)
2.1
属性：按是否使用static修饰，又分为:静态属性VS非静态属性(实例变量)
实例变量:我们创建了类的多个对象，每个对象都独立的拥有一套类中的非静态属性。
当修改其中一个对象中的非静态属性时,不会导致其他对象中同样的属性值的修改。
静态变量:我们创建了类的多个对象，多个对象共享同一个静态变量。当通过某一个对
象修改静态变量时，会导致其他对象调用此静态变量时,是修改过了的。
2.2
static修饰属性的其他说明:
①静态变量随着类的加载而加载。可以通过"类.静态变量"的方式进行调用
②静态变量的加载要早于对象的创建。
③由于类只会加载一次，则静态变量在内存中也只会存在一份:存在方法区的静态域
中。

	类变量	实例变量
类	yes	no
对象	yes	yes

使用static修饰方法:静态方法
①随着类的加载而加载．可以通过"类.静态方法"的方式进行调用

	静态方法	非静态方法
类	yes	no
对象	yes	yes

static注意点:
①在静态的方法内，不能使用this关键字、super关键字（生命周期）
②关于静态属性和静态方法的使用，大家都从生命周期的角度去理解。
开发中,如何确定一个属性是否要声明为static的?

属性是可以被多个对象所共享的,不会随着对象的不同而不同的。
类中的常量也常常声明为static

开发中,如何确定一个方法是否要声明为static的？

操作静态属性的方法，通常设置为static的
工具类的方法，习惯上声明为static的。比如:Math、 Arrays、Collections

子类和父类中的同名同参数的方法要么都声明为非static的(考虑重写)，要么都声明为static的

final关键字

final:最终的

final可以用来修饰的结构:类、方法、变量
final用来修饰一个类:此类不能被其他类所继承。
比如:String类、System类、StringBuffer类
final用来修饰方法:表明此方法不可以被重写
比如:Object类中getclass();
final用来修饰变量:此时的"变量"就称为是一个常量
①final修饰属性:可以考虑赋值的位置有:显式初始化、代码块中初始化、构造器中初始化
②final修饰局部变量:
尤其是使用final修饰形参时，表明此形参是一个常量。当我们调用此方法时，给常量形参赋一个实参。一旦赋值以后，就只能在方法体内使用此形参，但不能进行重新赋值。
static final用来修饰属性：全局常量

abstract关键字

1.abstract:抽象的
2.abstract可以用来修饰的结构:类、方法
3. abstract修饰类:抽象类

此类不能实例化
抽象类中一定有构造器，便于子类实例化时调用（涉及:子类对象实例化的全过程)
开发中，都会提供抽象类的子类,让子类对象实例化，完成相关的操作

abstract修饰方法:抽象方法

抽象方法只有方法的声明，没有方法体
包含抽象方法的类，一定是一个抽象类。反之，抽象类中可以没有抽象方法的。
若子类重写了父类中的所有的抽象方法后，此子类方可实例化
若子类没有重写父类中的所有的抽象方法，则此子类也是一个抽象类需要使用abstract修饰

抽象方法没有方法体，不能被调用，所以所处类也只能是抽象类，来避免类被实例化从而调方法
abstract使用上的注意点:

abstract不能用来修饰:属性、构造器等结构
abstract不能用来修饰私有方法、静态方法、final的方法、final的类
匿名子类的匿名对象

抽象类叫实现，非抽象类叫重写

常用方法

equals（）

equals()方法的使用：

是一个方法，而非运算符
只能适用于引用数据类型
Object类中equals()的定义：

  public boolean equals(Object obj) {
	        return (this == obj); 
  }

说明：Object类中定义的equals()和==的作用是相同的：比较两个对象的地址值是否相同.即两个引用是否指向同一个对象实体

像String、Date、File、包装类等都重写了Object类中的equals()方法。重写以后，比较的不是两个引用的地址是否相同，而是比较两个对象的"实体内容"是否相同。
通常情况下，我们自定义的类如果使用equals()的话，也通常是比较两个对象的"实体内容"是否相同。那么，我们就需要对Object类中的equals()进行重写.
重写的原则：比较两个对象的实体内容是否相同.

== ：运算符

可以使用在基本数据类型变量和引用数据类型变量中
如果比较的是基本数据类型变量：比较两个变量保存的数据是否相等。（不一定类型要相同）
如果比较的是引用数据类型变量：比较两个对象的地址值是否相同.即两个引用是否指向同一个对象实体补充： == 符号使用时，必须保证符号左右两边的变量类型一致。

toString（）

Object类中toString()的使用：

当我们输出一个对象的引用时，实际上就是调用当前对象的toString()
Object类中toString()的定义：

  public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
     }

像String、Date、File、包装类等都重写了Object类中的toString()方法。
使得在调用对象的toString()时，返回"实体内容"信息
自定义类也可以重写toString()方法，当调用此方法时，返回对象的"实体内容"

Java新特性

自动装箱与自动拆箱

java是面向对象的语言,然而八种基本类型并没有面向对象的特点.因此引入了包装类

针对八种基本数据类型定义相应的引用类型—包装类（封装类)
有了类的特点，就可以调用类中的方法，Java才是真正的面向对象

基本数据类型所对应的包装类

//包装类--->基本数据类型:调用包装类Xxx的xxxValue()
		Integer in1 = new Integer(12);
		int i1 = in1.intValue();
		System.out.println(i1 + 1);//13
		
		Float f1 = new Float(12.3);
		float f2 = f1.floatValue();
		System.out.println(f2 + 1);//13.3
//基本数据类型 --->包装类：调用包装类的构造器
		int num1 = 10;
//		System.out.println(num1.toString());
		Integer in1 = new Integer(num1);
		System.out.println(in1.toString());

		Float f1 = new Float(12.3f);

		Boolean b1 = new Boolean(true);
		Boolean b2 = new Boolean("TrUe");//只要是true不区分大小写都输出true

**JDK5.0新特性**基本数据类型与包装类之间有*自动装箱*和*自动拆箱*
//自动装箱：基本数据类型 --->包装类
		int num2 = 10;
		Integer in1 = num2;//自动装箱
		
		boolean b1 = true;
		Boolean b2 = b1;//自动装箱
		
		//自动拆箱：包装类--->基本数据类型
		System.out.println(in1.toString());
		
		int num3 = in1;//自动拆箱

String类型 —>基本数据类型、包装类：调用包装类的parseXxx(String s)

@Test
	public void test5(){
		String str1 = "123";
		//错误的情况：
//		int num1 = (int)str1;
//		Integer in1 = (Integer)str1;
		//可能会报NumberFormatException
		int num2 = Integer.parseInt(str1);
		System.out.println(num2 + 1);
		
		String str2 = "true1";
		boolean b1 = Boolean.parseBoolean(str2);
		System.out.println(b1);
	}

基本数据类型、包装类—>String类型：调用String重载的valueOf(Xxx xxx)

@Test
	public void test4(){
		
		int num1 = 10;
		//方式1：连接运算
		String str1 = num1 + "";
		//方式2：调用String的valueOf(Xxx xxx)
		float f1 = 12.3f;
		String str2 = String.valueOf(f1);//"12.3"
		
		Double d1 = new Double(12.4);
		String str3 = String.valueOf(d1);
		System.out.println(str2);
		System.out.println(str3);//"12.4"
		
	}

拓展知识

JavaBean

JavaBean是一种Java语言写成的可重用组件，是指符合如下标准的Java类：
①类是公共的
②有一个无参的公共的构造器有属性
③ 有属性，且有对应的get、set方法

UML类图

在这里插入图片描述

MVC设计模式

在这里插入图片描述

单例模式

在这里插入图片描述

单例设计模式:

所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例。
如何实现?
饿汉式vs 懒汉式（代码）

饿汉式

//饿汉式
class Bank{
	
	//1.私有化类的构造器（避免随意造对象）
	private Bank(){
		
	}
	//2.内部创建类的对象
	//4.要求此对象也必须声明为静态的（静态方法只能调静态结构）
	private static Bank instance = new Bank();
	
	//3.提供公共的静态的方法，返回类的对象
	public static Bank getInstance(){
		return instance;
	}
}

懒汉式

//懒汉式
public class SingletonTest2 {
	public static void main(String[] args) {
		
		Order order1 = Order.getInstance();
		Order order2 = Order.getInstance();
		
		System.out.println(order1 == order2);
		
	}
}


class Order{
	
	//1.私有化类的构造器
	private Order(){
		
	}
	
	//2.声明当前类对象，没有初始化
	//4.此对象也必须声明为static的
	private static Order instance = null;
	
	//3.声明public、static的返回当前类对象的方法
	public static Order getInstance(){
		
		if(instance == null){
			
			instance = new Order();
			
		}
		return instance;
	}
	
}

区分饿汉式和懒汉式
饿汉式:
坏处:对象加载时间过长。
好处:饿汉式是线程安全的
懒汉式:
好处:延迟对象的创建。
目前的写法坏处:线程不安全。—>到多线程内容时，再修改

多态的应用:模板方法设计模式(TemplateMethod)

抽象类体现的就是一种模板模式的设计，抽象类作为多个子类的通用模板，子类在抽象类的基础上进行扩展、改造，但子类总体上会保留抽象类的行为方式。
解决的问题:
当功能内部一部分实现是确定的，一部分实现是不确定的。这时可以把不确定的部分暴露出去，让子类去实现。
换句话说，在软件开发中实现一个算法时，整体步骤很固定、通用，这些步骤已经在父类中写好了。但是某些部分易变，易变部分可以抽象出来，供不同子类实现。这就是一种模板模式。
eg：代理模式、工厂模式