04-面向对象编程（上）

04—面向对象编程（上）

1. 面向过程与面向对象

• 面向过程(POP) 与 面向对象(OOP)

  • 二者都是一种思想，面向对象是相对于面向过程而言的。面向过程，强调的是功能行为，以函数为最小单位，考虑怎么做。面向对象，将功能封装进对象，强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。
  • 面向对象更加强调运用人类在日常的思维逻辑中采用的思想方法与原则，如抽象、分类、继承、聚合、多态等。

• 面向对象的三大特征

  • 封装 (Encapsulation)
  • 继承 (Inheritance)
  • 多态 (Polymorphism)

• 例子：人把大象放进冰箱

  • 面向过程

    

  • 面向对象

    

2. Java基本元素：类和对象

2.1 面向对象的思想概述

• 类(Class)和对象(Object)是面向对象的核心概念。
  • 类是对一类事物的描述，是抽象的、概念上的定义
  • 对象是实际存在的该类事物的每个个体，因而也称为实例(instance)。
• “万事万物皆对象”
• 
  • 可以理解为：类 = 抽象概念的人；对象 = 实实在在的某个人
  • 面向对象程序设计的重点是类的设计
  • 类的设计，其实就是类的成员的设计

2.2 Java类及类的成员

• 常见的类的成员有：

  • 属 性：对应类中的成员变量

  • 行 为：对应类中的成员方法

    Field = 属性 = 成员变量

    Method = (成员)方法 = 函数

• 类的语法格式

  

3. 对象的创建和使用

• 创建对象语法： 类名 对象名 = new 类名();

• 使用“对象名.对象成员”的方式访问对象成员（包括属性和方法）

• Java中类与对象

  

• 类的访问机制：

  • 在一个类中的访问机制：类中的方法可以直接访问类中的成员变量。 （例外：static方法访问非static，编译不通过。）
  • 在不同类中的访问机制：先创建要访问类的对象，再用对象访问类中定义的成员。

3.1 对象的产生

class Person{
	int age;
	void shout(){
		System.out.println(“oh,my god! I am ” + age);
	}
}

Person p1 = new Person();执行完后的内存状态。

3.2 对象的使用

class PersonTest{
	public static void main(String[] args) { //程序运行的内存布局如下图
		Person p1 = new Person();
		Person p2 =new Person();
		p1.age = -30;
		p1.shout();
		p2.shout();
	}
}

3.3 对象的生命周期

3.5 内存解析

• 堆（Heap），此内存区域的唯一目的就是存放对象实例，几乎所有的对象实例都在这里分配内存。这一点在 Java虚拟机规范中的描述是：所有的对象实例以及数组都要在堆上分配。

• 通常所说的栈（Stack），是指虚拟机栈。虚拟机栈用于存储局部变量等。 局部变量表存放了编译期可知长度的各种基本数据类型（boolean、byte、 char 、 short 、 int 、 float 、 long 、 double）、对象引用（reference类型， 它不等同于对象本身，是对象在堆内存的首地址）。 方法执行完，自动释放。

• 方法区（Method Area），用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。

  

3.6 匿名对象

• 我们也可以不定义对象的句柄，而直接调用这个对象的方法。这样的对象叫做匿名对象。 如：new Person().shout();
• 使用情况
  • 如果对一个对象只需要进行一次方法调用，那么就可以使用匿名对象。
  • 我们经常将匿名对象作为实参传递给一个方法调用。

4. 类的成员之一：属性

• 语法格式：

  修饰符 数据类型 属性名 = 初始化值 ;

  • 说明1: 修饰符
    • 常用的权限修饰符有：private、缺省、protected、public
    • 其他修饰符：static、final (暂不考虑)
  • 说明2：数据类型
    • 任何基本数据类型(如int、Boolean) 或任何引用数据类型。
  • 说明3：属性名
    • 属于标识符，符合命名规则和规范即可。

4.1 变量的分类

• 在方法体外，类体内声明的变量称为成员变量。

• 在方法体内部声明的变量称为局部变量。

  

• 注意：二者在初始化值方面的异同:

  • 同：都有生命周期
  • 异：局部变量除形参外，均需显式初始化。

• 成员变量（属性）和局部变量的区别

  	成员变量	局部变量
  声明的位置	直接声名在类中	方法形参或内部、代码块内、构造器内
  修饰符	private、public、static、final等	不能用权限修饰符修饰，可以用final修饰
  初始化值	有默认化初始值	没有默认初始值，必须显示赋值，方可使用
  内存加载位置	堆空间或静态域内	栈空间

  

5. 类的成员之二：方法

5.1 什么是方法(method、函数):

• 方法是类或对象行为特征的抽象，用来完成某个功能操作。在某些语言中也称为函数或过程。

• 将功能封装为方法的目的是，可以实现代码重用，简化代码

• Java里的方法不能独立存在，所有的方法必须定义在类里。

  public class Person{
  	private int age;
  	public int getAge() { //声明方法getAge()
  		return age; 
  	}
  	public void setAge(int i) { //声明方法setAge
  		age = i; //将参数i的值赋给类的成员变量age
  	}
  }

5.2 方法的声明格式：

修饰符 返回值类型 方法名（参数类型 形参1, 参数类型 形参2, ….）｛

​ 方法体程序代码

​ return 返回值;

｝

• 其中：
  • 修饰符：public,缺省,private, protected等
  • 返回值类型：
    • 没有返回值：void。
    • 有返回值，声明出返回值的类型。与方法体中“return 返回值”搭配使用
  • 方法名：
    • 属于标识符，命名时遵循标识符命名规则和规范，“见名知意” 形参列表：可以包含零个，一个或多个参数。多个参数时，中间用“,”隔开 返回值：方法在执行完毕后返还给调用它的程序的数据。

5.3 方法的调用

方法通过方法名被调用，且只有被调用才会执行

• 方法调用的过程分析

  

• 注意

  • 方法被调用一次，就会执行一次
  • 没有具体返回值的情况，返回值类型用关键字void表示，那么方法体中可以不必使用return语句。如果使用，仅用来结束方法。
  • 定义方法时，方法的结果应该返回给调用者，交由调用者处理。
  • 方法中只能调用方法或属性，不可以在方法内部定义方法。

5.4 对象数组的内存解析

6. 再谈方法

6.1 方法的重载

• 重载的概念

  在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。

• 重载的特点：

  与返回值类型无关，只看参数列表，且参数列表必须不同。(参数个数或参数类型)。调用时，根据方法参数列表的不同来区别。

• 重载示例：

  //返回两个整数的和
  int add(int x,int y){return x+y;}
  //返回三个整数的和
  int add(int x,int y,int z){return x+y+z;}
  //返回两个小数的和
  double add(double x,double y){return x+y;}

6.2 可变个数的形参

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);

说明：

1. 声明格式：方法名(参数的类型名 …参数名)
2. 可变参数：方法参数部分指定类型的参数个数是可变多个：0个，1个或多个
3. 可变个数形参的方法与同名的方法之间，彼此构成重载
4. 可变参数方法的使用与方法参数部分使用数组是一致的，所以二者不能同名
5. 方法的参数部分有可变形参，需要放在形参声明的最后
6. 在一个方法的形参位置，最多只能声明一个可变个数形参

package First;

/**
 * @author Xiong
 * @create 2021-08-15-11:46
 */
public class TestOverload {
    public void test(String[] msg){
        System.out.println("含字符串数组参数的test方法 ");
    }
    public void test1(String book){
        System.out.println("****与可变形参方法构成重载的test1方法****");
    }
    public void test1(String ... books){
        System.out.println("****形参长度可变的test1方法****");
    }
    public static void main(String[] args){
        TestOverload to = new TestOverload();
        to.test1();
        to.test1("book");
        to.test1("aa" , "bb");
        //下面将执行第一个test方法
        to.test(new String[]{"aa"});
    }

}

形参长度可变的test1方法
与可变形参方法构成重载的test1方法
形参长度可变的test1方法
含字符串数组参数的test方法

6.3 方法参数的值传递机制

• 方法，必须由其所在类或对象调用才有意义。若方法含有参数：

  • 形参：方法声明时的参数
  • 实参：方法调用时实际传递给形参的参数值

• Java的实参值如何传入方法

  Java里方法的参数传递方式只有一种：值传递。即将实际参数值的副本（复制品）传入方法内，而参数本身不受影响

  • 形参时基本数据类型：将实参基本数据类型变量的“数据值”传递给形参

    

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

    

    

    

    

7. OOP特征一：封装与隐藏

7.1 信息的封装和隐藏

Java中通过将数据声明为私有的(private)，再提供公共的（public） 方法:getXxx()和setXxx()实现对该属性的操作，以实现下述目的：

• 隐藏一个类中不需要对外提供的实现细节；
• 使用者只能通过事先定制好的方法来访问数据，可以方便地加入控制逻辑， 限制对属性的不合理操作；
• 便于修改，增强代码的可维护性；

class Animal {
	private int legs;// 将属性legs定义为private，只能被Animal类内部访问
	public void setLegs(int i) { // 在这里定义方法 eat() 和 move()
		if (i != 0 && i != 2 && i != 4) {
			System.out.println("Wrong number of legs!");
			return;
		}
		legs = i;
	}
	public int getLegs() {
		return legs;
	}
}
public class Zoo {
	public static void main(String args[]) {
		Animal xb = new Animal();
		xb.setLegs(4); // xb.setLegs(-1000);
		//xb.legs = -1000; // 非法
		System.out.println(xb.getLegs());
	}
}

7.2 四种访问权限修饰符

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

修饰符	内部类	同一个包	不同包的子类	同一个工程
private	Yes
(缺省)	Yes	Yes
protected	Yes	Yes	Yes
public	Yes	Yes	Yes	Yes

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

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

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

8. 类的成员之三：构造器

8.1 创建构造器

• 构造器的特征

  • 它具有与类相同的名称
  • 它不声明返回值类型。（与声明为void不同）
  • 不能被static、final、synchronized、abstract、native修饰，不能有 return语句返回值

• 构造器的作用：创建对象；给对象进行初始化

  • 如：Order o = new Order(); Person p = new Person(“Peter”,15)
  • 如同我们规定每个“人”一出生就必须先洗澡，我们就可以在“人”的 构造器中加入完成“洗澡”的程序代码，于是每个“人”一出生就会自 动完成“洗澡”，程序就不必再在每个人刚出生时一个一个地告诉他们 要“洗澡”了。

• 语法格式

  修饰符 类名 (参数列表) { 初始化语句； }

• public class Animal {
      private int legs;
      // 构造器
      public Animal() {
          legs = 4;
      } 
      public void setLegs(int i) {
          legs = i;
      }
      public int getLegs() {
          return legs;
      }
  }
  * 创建Animal类的实例：Animal a = new Animal(); 调用构造器，将legs初始化为4。
  
  * 根据参数不同，构造器可以分为如下两类：
  
    * 隐式无参构造器（系统默认提供）
    * 显式定义一个或多个构造器（无参、有参）
  
  * 注意
  
    * Java语言中，每个类都至少有一个构造器
    * 默认构造器的修饰符与所属类的修饰符一致
    * 一旦显式定义了构造器，则系统不再提供默认构造器
    * 一个类可以创建多个重载的构造器
    * 父类的构造器不可被子类继承
  
  ##### 8.2 构造器重载
  
  * 构造器一般用来创建对象的同时初始化对象。如
  
    ```java
    class Person{
    String name;
    int age;
    public Person(String n , int a){ name=n; age=a;}
    }
  

• 构造器重载使得对象的创建更加灵活，方便创建各种不同的对象。

  public class Person{
  	public Person(String name, int age, Date d) {this(name,age);…}
  	public Person(String name, int age) {…}
  	public Person(String name, Date d) {…}
  	public Person(){…}
  }

• 构造器重载，参数列表必须不同

  public class Person { 构造器重载举例
  	private String name;
  	private int age;
  	private Date birthDate;
  	public Person(String n, int a, Date d) {
  		name = n;
  		age = a;
  		birthDate = d;
  	}
  	public Person(String n, int a) {
  		name = n;
  		age = a;
  	}
  	public Person(String n, Date d) {
  		name = n;
  		birthDate = d;
  	}
  	public Person(String n) {
  		name = n;
  		age = 30;
  	}
  }

8.3 属性赋值过程

• 赋值的位置：

  ① 默认初始化

  ② 显式初始化

  ③ 构造器中初始化

  ④ 通过“对象.属性“或“对象.方法”的方式赋值

• 赋值的先后顺序： ① - ② - ③ - ④

8.4 JavaBean

• JavaBean是一种Java语言写成的可重用组件。

• 所谓javaBean，是指符合如下标准的Java类：

  • 类是公共的
  • 有一个无参的公共的构造器
  • 有属性，且有对应的get、set方法

• 用户可以使用JavaBean将功能、处理、值、数据库访问和其他任何可以 用Java代码创造的对象进行打包，并且其他的开发者可以通过内部的JSP 页面、Servlet、其他JavaBean、applet程序或者应用来使用这些对象。用 户可以认为JavaBean提供了一种随时随地的复制和粘贴的功能，而不用关心任何改变。

  public class JavaBean {
  	private String name; // 属性一般定义为private
  	private int age;
  	public JavaBean() {
  	}
  	public int getAge() {
  		return age;
  	}
  	public void setAge(int a) {
  		age = a;
  	}
  	public String getName() {
  		return name;
  	}
  	public void setName(String n) {
  		name = n;
  	}
  }

8.5 UML类图

1. + 表示 public 类型， - 表示 private 类型，#表示protected类型
2. 方法的写法: 方法的类型(+、-) 方法名(参数名： 参数类型)：返回值类型

9. 关键字：this

9.1 this是什么?

• 在Java中，this关键字比较难理解，它的作用和其词义很接近。

  • 它在方法内部使用，即这个方法所属对象的引用；
  • 它在构造器内部使用，表示该构造器正在初始化的对象。

• this 可以调用类的属性、方法和构造器

• 什么时候使用this关键字呢？

  • 当在方法内需要用到调用该方法的对象时，就用this。
  • 具体的：我们可以用this来区分属性和局部变量。 比如：this.name = name;

• 使用this，调用属性、方法

  class Person{ // 定义Person类
  	private String name ;
  	private int age ;
  	public Person(String name,int age){
  		this.name = name ; 
  		this.age = age ; 
      }
  	public void getInfo(){
  		System.out.println("姓名：" + name) ;
  		this.speak();
  	}
  	public void speak(){
  		System.out.println(“年龄：” + this.age);
  	}
  }

  • 1. 在任意方法或构造器内，如果使用当前类的成员变量或成员方法可以在其前面添加this， 增强程序的阅读性。不过，通常我们都习惯省略this。
    2. 当形参与成员变量同名时， 如果在方法内或构造器内需要使用成员变量，必须添加this来表明该变量是类的成员变量
    3. 使用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 ;
  	} 
  }

  • 4. .this可以作为一个类中构造器相互调用的特殊格式

• 注意：

  • 可以在类的构造器中使用”this(形参列表)”的方式，调用本类中重载的其他的构造器！
  • 明确：构造器中不能通过”this(形参列表)”的方式调用自身构造器
  • 如果一个类中声明了n个构造器，则最多有 n - 1个构造器中使用了 “this(形参列表)”
  • “this(形参列表)”必须声明在类的构造器的首行！
  • 在类的一个构造器中，最多只能声明一个”this(形参列表)”

10. 关键字：package、import

10.1 关键字—package

• package语句作为Java源文件的第一条语句，指明该文件中定义的类所在的包。(若缺省该语句，则指定为无名包)。它的格式为： package 顶层包名.子包名 ;

  举例：pack1\pack2\PackageTest.java

  package pack1.pack2; //指定类PackageTest属于包pack1.pack2
  public class PackageTest{
  	public void display(){
  		System.out.println("in method display()");
  	}
  }

  包对应于文件系统的目录，package语句中，用 “.” 来指明包(目录)的层次；

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

• 源文件布局：

  • Java源文件基本语法

    [<包声明>]

    ​ [<导入声明>]

    ​ <类声明>+

  • 示例，VehicleCapacityReport.java文件

    package shipping.reports;
    
    import shipping.domain.*;
    import java.util.List;
    import java.io.*;
    
    public class VehicleCapacityReport {
        private List vehicles;
        public void generateReport(Writer output){ ...}
    }

包的作用：

• 包帮助管理大型软件系统：将功能相近的类划分到同一个包中。比如：MVC的设计模式

• 包可以包含类和子包，划分项目层次，便于管理

• 解决类命名冲突的问题

• 控制访问权限

  例：某航运软件系统包括：一组域对象、GUI和reports子系统

  

MVC设计模式

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

JDK中主要的包介绍

1. java.lang—-包含一些Java语言的核心类，如String、Math、Integer、 System和 Thread，提供常用功能
2. java.net—-包含执行与网络相关的操作的类和接口。
3. java.io —-包含能提供多种输入/输出功能的类。
4. java.util—-包含一些实用工具类，如定义系统特性、接口的集合框架类、使用与日期日历相关的函数。
5. java.text—-包含了一些java格式化相关的类
6. java.sql—-包含了java进行JDBC数据库编程的相关类/接口
7. java.awt—-包含了构成抽象窗口工具集（abstract window toolkits）的多个类，这些类被用来构建和管理应用程序的图形用户界面(GUI)。 B/S C/S

10.2 关键字—import

• 为使用定义在不同包中的Java类，需用import语句来引入指定包层次下所需要的类或全部类(.*)。import语句告诉编译器到哪里去寻找类。
• 语法格式： import 包名. 类名;
• 注意
  1. 在源文件中使用import显式的导入指定包下的类或接口
  2. 声明在包的声明和类的声明之间。
  3. 如果需要导入多个类或接口，那么就并列显式多个import语句即可
  4. 举例：可以使用java.util.*的方式，一次性导入util包下所有的类或接口。
  5. 如果导入的类或接口是java.lang包下的，或者是当前包下的，则可以省略此import语句。
  6. 如果在代码中使用不同包下的同名的类。那么就需要使用类的全类名的方式指明调用的 是哪个类。
  7. 如果已经导入java.a包下的类。那么如果需要使用a包的子包下的类的话，仍然需要导入。
  8. import static组合的使用：调用指定类或接口下的静态的属性或方法