【Java学习笔记】第四章面向对象编程三部曲（上）

【Java学习笔记】第四章面向对象编程三部曲（中）

【Java学习笔记】第四章面向对象编程三部曲（下）

文章目录

4.面向对象编程（上）
- 4.1面向过程和面向对象
- 4.2类和对象
- - 4.2.1类对象得使用
  - 4.2.2类对象的内存解析
  - 4.2.3匿名对象
- 4.3类的成员之一：属性
- - 4.3.1成员变量和局部变量
- 4.4 类的成员之二：方法（函数）
- - 4.4.1 方法基本使用
  - 4.4.2 方法重载overload
  - 4.4.3 可变个数形参
  - 4.4.4 方法参数的值传递机制
  - 4.4.5 递归（recursion）方法
- 4.5 面向对象的特征之一封装性
- - 4.5.1 四种访问权限修饰符
- 4.6类的成员之三：构造器（构造方法）
- 4.7 JavaBean
- 4.8 UML类图
- 4.9 this的使用
- 4.10关键字package
- - 4.10.1 JDK常用的包
  - 4.10.2 MVC设计模式
- 4.11关键字import

4.面向对象编程（上）

4.1面向过程和面向对象

面向过程 Procedure Oriented Programming (POP)

面向对象 Object Oriented Programming (OOP)

面向对象三大特征：封装，继承，多态

4.2类和对象

类是对一类事物得抽象，对象是类得实例化

类的五部分：属性+方法（函数）+构造器+代码块+内部类

Field = 属性 = 成员变量，Method = (成员)方法= 函数

4.2.1类对象得使用

定义类

修饰符 class 类名
{
	属性声明；
	方法声明；
}

创建对象

创建对象：类名对象名=new 类名( );//调用构造器在堆区开辟空间

访问对象

”对象名.对象成员“来访问对象中的属性和方法

类得访问机制

类内方法直接访问属性，静态方法访问静态变量，非静态方法访问非静态变量。

对象的产生

Person p1 = new Person();

对象的生命周期

4.2.2类对象的内存解析

堆（Heap）：存放对象实例。Java虚拟机规范中描述的是：所有对象实例以及数组都要在堆上分配
栈：通常说的栈指的是虚拟机栈。虚拟机栈用于存储局部变量等。局部变量表存放了编译期可知长度的各种基本数据类型（boolean，char，byte，short，int，long，float，double），引用数据类型（reference类型，它不等同于对象本身，它是对象在堆区存放的首地址）。方法执行完，自动释放。
方法区（Method Area），用于存放已被虚拟机加载的类信息，常量，静态变量，即时编译器编译后的代码等数据。

实例1:（引用数据类型变量只能存储两种类型的值：null 或地址值（含变量类型））

实例2：对象数组的内存解析（引用数据类型变量只能存储两种类型的值：null 或地址值（含变量类型））

4.2.3匿名对象

我们也可以不定义对象的句柄，而直接调用这个对象的方法。这样的对象叫做匿名对象。就是没有名称标识的对象，如new Person().short();

使用情况

如果对一个对象只需要进行一次方法调用，那么就可以使用匿名对象。
我们经常将匿名对象作为实参传递给一个方法调用。

特定堆区有对象没名字，所以一般来说只能使用一次。

准确点来说，叫做非匿名类的匿名对象，后面面向对象（下）抽象类中还有匿名子类的非匿名对象和匿名子类的匿名对象创建创建。
public class InstanceTest {
	public static void main(String[]args)
	{
		new Person().height=100;
		new Person().print();//身高：0.0 体重：0.0
		//每次new的对象都不是同一个对象，所以第二个值输出是0.0

		//匿名对象的使用
		Chinese Lin=new Chinese();
		Lin.show(new Person());//匿名对象的使用场景之一
	}
}
class Person
{
	double height;
	double weight;

	public void print()
	{
		System.out.println("身高："+height+" 体重"+weight);
	}
}
class Chinese
{
	public void show(Person person)
	{
		person.print();
		person.print();
	}
}
上述例子中Lin.show(new Person()); new Person()在堆区开辟了person大小的空间，返回地址值，赋值给函数形参变量。由此可见new的返回值是地址值哦。可以发现这次的匿名对象在函数体中被调用了两次，原因就是通过赋值形参的过程记录下了匿名对象。所以匿名对象一般来说只能使用一次，但也有例外。

4.3类的成员之一：属性

语法格式：修饰符数据类型属性名 = 初始化值；

修饰符：public，protected，缺省，private，static，final

数据类型：基本数据类型或任何引用类型

属性名：就是标识符

注意修饰符只能用于属性权限的修饰，不能用于局部变量的修饰

4.3.1成员变量和局部变量

区别

成员变量初始化值如下。局部变量出形参外均需要显示赋值。

4.4 类的成员之二：方法（函数）

4.4.1 方法基本使用

方法是类或对象行为的抽象，用来完成某个特定的功能。目的是提高代码的重用性，简化代码。Java中方法不能独立存在，所有的方法必须定义在类里

方法的生命格式：

修饰符 返回值类型 方法名（参数类型 形参1, 参数类型 形参2, ….）
｛
		方法体程序代码
        return 返回值; 
		//如果函数返回类型是void，结尾要么写return;要么不写
		//如果函数返回类型非void，结尾一定要写return 数据;
｝

修饰符：public，protected，缺省，private，static，final，abstract

方法名：就是标识符，符合规范+见名知意

形参列表：局部变量中除了形参外都要显示初始化

方法的调用过程

生成类的成员get、set方法

在这里设置相应的输入输出函数

4.4.2 方法重载overload

重载的概念：允许一个类中存在多个形参列表不同的重名方法
重载须知：不支持以返回值类型的重载，只支持参数列表作为方法重载的标准(参数个数，参数顺序或参数类型)。
方法的调用方式：
按名字找方法
若有重载，则按参数列表匹配方法
若没有完全匹配的参数列表，看是否遵守自动类型提升，还是没有，就凉凉咯。

System.out.println()方法就是典型的重载方法，它能输出不同的数据就是因为其内部的对不同数据类型进行了重载，系统预定义的数据类型，而对自定义的数据类型，则需要程序员自行重载。

上述println重载的函数中值得关注的是char[]和String同为引用数据类型，普通的对象也是引用数据类型，他们存储的都是地址值println(char[]) println(String) println(object)时前面两个输出的是地址值所指空间内容，这是因为库中预先定义好的对这两种引用类型特殊的处理方式。

而对于一般的object，我们来看看println(object)在API文档怎么说：就是打印对象的字符串值！

4.4.3 可变个数形参

JavaSE 5.0 中提供了**Varargs(variable number of arguments)**机制，允许直接定义能和多个实参相匹配的形参。从而，可以用一种更简单的方式，来传递个数可变的实参。

//JDK 5.0以前：采用数组形参来定义方法，传入多个同一类型变量public static void test(int a ,String[] books);

//JDK5.0：采用省略号方式来定义方法，传入多个同一类型变量public static void test(int a ,String…books);

声明格式：方法名(参数的类型名 …参数名)
可变参数：调用方法时实参数个数是任意个：0个，1个或多个

特殊的，当调用方法实参个数是零个，且如果存在多个可变形参方法，编译器是无法匹配到底是那个方法，爆出以下错误：捉摸不透的。
可变个数形参的方法与同名的方法之间，彼此构成重载

但需注意在编译器不支持，省略号方式和相应数据类型的数组两种凡是定义的可变个数形参不能作为区分形参列表的标准，换而言之不支持这样的方法重载的。也就是说不存在以下匹配：
以上述两个重复的方法为例，更值得注意的是虽然编译器不支持这样的重载，但这两个在编译器看来任然是不同的方法，如上橙色框框，show(String…)和show(String[])。所以调用上是不同的：

推荐使用三点来定义可变个数形参！因为它使用范围更广。
```
MethodArgsTest test = new MethodArgsTest();//上述方法的对象
test.show("hellow"+"word");
//调用show(String...)无法调用show(String[])
test.show(new String[]{"hellow","word"});//匿名对象的使用
//调用show(String[])，也可以调用show(String...)
```

如何使用可变个数形参？就当作数组来使用即可！

public void show(String ... str)
{
    for(int i=0;i<str.length;i++)
    {
        System.out.println(str[i]);
    }
}

同一个方法中，最多只能声明一个可变个数形参，且必须写在形参列表的结尾。原因都是编译器无法预知你要如何分配实参变量！

4.4.4 方法参数的值传递机制

形参：方法声明时的参数

实参：方法调用时实际传给形参的参数值

ava方法的参数传递方式只有一种值传递！即将实参的副本传入方法内，而实参本身不受影响。

形参是基本数据类型：将实参基本数据类型变量的“数据值”传递给形参
形参是引用数据类型：将实参引用数据类型变量的“地址值”传递给形参

基本数据类型变量在栈中存的就是数据本身，而引用数据类型的变量存的是引用数据类型对象在栈区的是地址值，指向堆区开辟的空间。所以在方法参数传递时，都是传值。但基本数据类型的形参的改变影响的是实参的拷贝而非实参本身，相比之下引用数据类型的形参能改变实参就是因为有地址值。总的来说想要改变实参就得用引用数据类型。

4.4.5 递归（recursion）方法

一个方法体内调用它自身。（在树中用的很广泛）

public int getSum(int n)//n!求和
{
	if(n==1) return 1;
	else return n*getSum(n-1);
}

4.5 面向对象的特征之一封装性

程序追求高内聚低耦合的特点，所谓的高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合就是对外仅暴露少量的方法用于使用。
隐藏对象的复杂性，只对外公开简单的接口。便于外界调用，从而提高系统的可扩展性，可维护性。通俗额说，把该隐藏的隐藏起来，该暴露的暴露出来。四种权限就是封装性得理解。这就是封装性的设计思想。

表现：Java通过将属性声明为私有，再对外提供公共getset的方法实现对该属性的操作。这样做的优点有：
- 隐藏一个类中不需要对外提供的实现细节；
- 使用者只能通过事先定制好的方法来访问数据，可以方便地加入控制逻辑，限制对属性的不合理操作；
- 便于修改，增强代码的可维护性；

4.5.1 四种访问权限修饰符

Java权限修饰符public、(缺省)、protected、private置于类的成员定义前，用来限定对象对该类成员的访问权限。

对于class的权限修饰只可以用public和default(缺省)。

public类可以在任意地方被访问。

default类只可以被同一个包内部的类访问。

4.6类的成员之三：构造器（构造方法）

构造器的特点：

与类相同的名称
无返回值
不能被static、final、synchronized、abstract、native修饰

构造器的作用：创建对象，堆区开辟空间，给对象初始化（对于一个对象，如果我们希望它与生俱来就具有某些特征，那么我们往往会再构造器中区实现）

构造器的语法：修饰符类名 (参数列表) { 初始化语句；}

根据参数不同，构造器可以分为

隐式无参构造器（默认构造器）

显式定义一个或多个构造器（无参、有参）

默认构造器的修饰符与所属类的修饰符一致
一旦显式定义了构造器，则系统不再提供默认构造器（一般来说我们都会给类提供一个默认构造器）
允许构造器重载，是的对象的创建变得更加灵活，方便创建各种不同的对象

4.7 JavaBean

JavaBean是一种Java语言写成的可重用组件。
所谓javaBean，是指符合如下标准的Java类：
1. 类是公共的
2. 有一个无参的公共的构造器
3. 有属性，且有对应的get、set方法
用户可以使用JavaBean将功能、处理、值、数据库访问和其他任何可以用Java代码创造的对象进行打包，并且其他的开发者可以通过内部的JSP页面、Servlet、其他JavaBean、applet程序或者应用来使用这些对象。用户可以认为JavaBean提供了一种随时随地的复制和粘贴的功能，而不用关心任何改变。

4.8 UML类图

+表示 public 类型， - 表示 private 类型，#表示protected类型

方法的写法:

方法的权限(+、-) 方法名(参数名：参数类型)：返回值类型

4.9 this的使用

this在方法内，指调用该方法的对象的引用（当前对象）
this在构造器内，表示该构造器正在初始化的对象

this可以调用属性、方法、构造器

在任意方法或构造器内，如果使用当前类的成员变量或成员方法可以在其前面添加this，增强程序的阅读性。不过，通常我们都习惯省略this。

当形参与成员变量同名时，如果在方法内或构造器内需要使用成员变量，必须添加this来表明该变量是类的成员变量。

使用this访问属性和方法时，如果在本类中未找到，会从父类中查找

this可以作为一个类中构造器相互调用的特殊格式
```
class Person
{ 
 // 定义Person类

 private String name ;
 private int age ;
 public Person()
 { // 无参构造器
     System.out.println("新对象实例化") ;
 }
 public Person(String name)
 {
     this(); // 调用本类中的无参构造器
     this.name = name ;
 }
 public Person(String name,int age)
 {
     this(name) ; // 调用有一个参数的构造器
     this.age = age;
 }
 public String getInfo()
 {
     return "姓名：" + name + "，年龄：" + age ;
 } 
}
```
1. 可以在类的构造器中使用"this(形参列表)"的方式，调用本类中重载的其他的构造器！
2. 明确：构造器中不能通过"this(形参列表)"的方式调用自身构造器（死循环）
3. 如果一个类中声明了n个构造器，则最多有 n - 1个构造器中使用了"this(形参列表)"（不能出现我调你，你调我，死循环）
4. "this(形参列表)"必须声明在类的构造器的首行！
5. 在类的一个构造器中，最多只能声明一个"this(形参列表)"（首行的语法要求决定了这样的情况不会出现）

4.10关键字package

package语句作为Java源文件的第一条语句，指明该文件中定义的类所在的包（若缺省该语句，则指定为无名包），同一个包下，不能命名相同的接口、类

package 顶层包名.子包名

举例：pack1.pack2.PackageTest.java

(包对应于文件系统的目录，package语句中，用 “.” 来指明包(目录)的层次。每“.”一次就相当于一层文件目录，在Navigator窗口点开src文件夹可以查看)

包通常用小写单词标识。通常使用所在公司域名的倒置：com.tencent.xxx

源文件布局：

//<包声明>
//<导入包>
//<类声明>

包的作用

包帮助管理大型软件系统：将功能相近的类划分到同一个包中。比如：MVC的设计模式
包可以包含类和子包，划分项目层次，便于管理
解决类命名冲突的问题
控制访问权限

4.10.1 JDK常用的包

java.lang----包含一些Java语言的核心类，如String、Math、Integer、 System和Thread，提供常用功能

java.net----包含执行与网络相关的操作的类和接口。

java.io ----包含能提供多种输入/输出功能的类。

java.util----包含一些实用工具类，如定义系统特性、接口的集合框架类、使用与日期日历相关的函数。

java.text----包含了一些java格式化相关的类

java.sql----包含了java进行JDBC数据库编程的相关类/接口

java.awt----包含了构成抽象窗口工具集（abstract window toolkits）的多个类，这些类被用来构建和管理应用程序的图形用户界面(GUI)。 B/S C/S

4.10.2 MVC设计模式

MVC是常用的设计模式之一(包管理的设计模式)，将整个程序分为三个层次：视图层（V），控制层（C），模型层（M）。这种将程序输入输出、数据处理，以及数据的展示分离开来的设计模式使程序结构变的灵活而且清晰，同时也描述了程序各个对象间的通信方式，降低了程序的耦合性。

过程：

4.11关键字import

在源文件中显示的使用import结构导入指定包下的类、接口。

语法格式：import 包名. 类名;（或import 包名.*）

单个类(.类名)或全部类(.*)。

注意import关键字最后的落脚点一定是类！import全部类用的是（.*） *代表的是匿名，指代全部的类，至于其他的都要 .类名。

在源文件中使用import显式的导入指定包下的类或接口
导包在当前包声明和类的声明之间。
如果需要导入多个类或接口，那么就并列显式多个import语句即可
可以使用java.util.*的方式，一次性导入util包下所有的类或接口。
如果导入的类或接口是java.lang包下的（如String，System类），或者是当前包下的，则可以省略此import语句。java.lang包是java的一些核心包，可以直接使用
如果在代码中使用不同包下的同名的类。那么就需要使用类的全类名的方式指明调用的是哪个类。

特别注意：当需要使用不同包下的类，但该类具有相同的类名，这个时候，你希望同时不同包下同名的类，会出现

下方的含两个参数的构造器在com.atguigu.java1包下，当导入的时候报错：您导入的Circle和另一个导入冲突了（collides），对此的做法是：在定义类的时候使用全类名。
如果已经导入java.a包下的类（.*方式）。那么如果需要使用a包的子包下的类的话，仍然需要导入。（所以java.lang的子包任然需要导入）
import static 组合的使用：调用指定类或接口下的静态的属性或方法