第4章 面向对象-上

一、类与对象

1.java面向对象学习的三条主线(第4-6章)

 1.java类及类的成员：属性、方法、构造器；代码块、内部类
 2.面向对象的三大特征：封装性、继承性、多态性、(抽象性)
 3.其他关键字：this、super、static、final、abstract、interface、packge、import等 

2.“人把大象装进冰箱里”

1.面向过程

Object Oriented Programming强调的是功能行为，以函数为最小单位，考虑怎么做
     ①把冰箱门打开
     ②抬起大象，塞进冰箱
     ③把冰箱门关闭

2.面向对象

Procedure Oriented Programming强调具备了功能的对象，以类/对象为最小单位，考虑谁来做

人{
             打开(冰箱){
                         冰箱.开开();                        
             }  
             
             抬起(大象){
                         大象，进入(冰箱);
             }  
 
             冰箱.闭合();
     } 
     
     冰箱{
            开开(){}
             闭合(){}
     }
     
     大象{
             进入(冰箱){}
     }

面向对象的思想概述：程序员从面向过程的执行者转化成了面向对象的指挥者

面向对象分析方法、问题的思路和步骤：

（1）根据问题需要，选择问题所针对的现实世界中的实体。

（2）从实体中寻找解决问题相关的属性和功能，这些属性和功能就形成了概念世界中的类。

（3）把抽象的实体用计算机语言进行描述，形成计算机世界中类的定义。即借助某种程序语言，把类构造成计算机能够识别和处理的数据结构。

（4）将类实例化成计算机世界中的对象。对象是计算机世界中解决问题的最终工具。

3.面向对象的两个要素:类、对象

 类：对一类事物的描述，是抽象的、概念上的定义
 对象：实际存在的该类事物的每个个体，因而也称为实例(instance)
     >面向对象程序设计的重点是类的设计

（1）设计类，就是设计类的成员

    属性 = 成员变量 = field = 域、字段            方法 = 成员方法 = 函数 = method
            创建类的对象 = 类的实例化 = 实例化类

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

      1.创建类，设计类的成员
      2.创建类的对象
      3.通过“对象.属性”或“对象.方法”调用对象的结构

//类的成员构成1.0
class{
    //属性
    //方法
}

（3）如果创建了一个类的多个对象，则每个对象都独立的拥有一套类的属性。(非static的) 

     意味着：如果我们修改一个对象的属性a，则不影响另外一个对象属性a的值。

（4）对象的内存解析

//测试类
public class PersonTest {
	public static void main(String[] args) {
		//2.创建Person类的对象
		Person p1 = new Person();
		//Scanner scanner = new Scanner(System.in);
		
		//调用对象的结构：属性、方法
		//调用属性：“对象.属性”
		p1.name = "Tom";
		p1.isMale = true;
		System.out.println(p1.name);
		
		//调用方法：“对象.方法”
		p1.eat();
		p1.sleep();
		p1.talk("Chinese");
		
		//****************************
		Person p2 = new Person();
		System.out.println(p2.name);//null
		System.out.println(p2.isMale);//false
		//**************************
		//将p1变量保存的对象地址值赋给p3，导致p1、p3指向了堆空间中的同一个对象实体
		Person p3 = p1;
		System.out.println(p3.name);
		
		p3.age = 10;
		System.out.println(p1.age);
	}
}
//1.创建类，设计类的成员
class Person{
	
	//属性
	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);
	}
	
}

4.JVM内存结构

编译完源程序后，生成一个或多个字节码文件。
      我们使用JVM中的类的加载器和解释器对生成的字节码文件进行解释运行。意味着，需要将字节码文件对应的类加载到内存中，涉及到内存解析。 
《JVM规范》
          虚拟机栈，即为平时提到的栈结构。我们将局部变量存储在栈结构中。
          堆，我们将new出来的结构(如：数组、对象)加载在堆空间中。补充：对象的属性(非static的)加载在堆空间中。
         方法区：类的加载信息、常量池、静态域

二、类的结构之一：属性

 属性(成员变量) vs 局部变量

（变量的分类2.0） 

1.相同点

  ①定义变量的格式：数据类型 变量名 = 变量值
  ②先声明，后使用
  ③变量都有其对应的作用域

2.不同点

①在类中声明的位置不同
属性：直接定义在类的一对{}内
局部变量：声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量
②关于权限修饰符的不同
属性：可以在声明属性时，指明其权限，使用权限修饰符
         常用的权限修饰符：private、public、缺省、protected ---> 封装性
局部变量：不可以使用权限修饰符
③默认初始化值的情况
属性：类的属性，根据其类型，都有默认初始化值。
        整型(byte、short、int、long):0
        浮点型(float、double):0.0
        字符型(char):0 (或'\u0000')
        布尔型(boolean):flase
        引用数据类型(类、数组、接口)：null
局部变量：没有默认初始值。 意味着，我们在调用局部变量之前，一定要显式赋值。特别地，形参在调用时，我们赋值即可。
④在内存中加载的位置
属性：加载到堆空间中(非static)
局部变量：加载到栈空间

public class UserTest {
	public static void main(String[] args) {
		User u1 = new User();
		System.out.println(u1.name);//null
		System.out.println(u1.age);//0
		System.out.println(u1.isMale);//false
		
		u1.talk("德语");
		
		u1.eat();
	}
}

class User{
	//属性(或成员变量)
	String name;
	public int age;
	boolean isMale;
	
	public void talk(String language) {//此处language为形参，是局部变量
		System.out.println("我们使用" + language + "进行交流");
	}
	
	public void eat() {
		String food = "烙饼";//局部变量
		System.out.println("北方人喜欢吃：" + food);
	}
	
}

三、类的结构之二：方法

 方法：描述类应该具有的功能
      如：Math类：sqrt() \ random() \···        Scanner类：nextXxx() ···
             Arrays类：sort() \ binarySearch() \ toString() \ equals() \···

方法的分类：按照是否有形参及返回值

	无返回值	有返回值
无形参	void 方法名( ) {}	返回值的类型 方法名( ) {}
有形参	void 方法名( 形参列表 ) {}	返回值的类型 方法名( 形参列表 ) {}

1.举例

  public void eat(){}        public void sleep(int hour){}
  public String getName(){}        public String getNation(String nation){}

2.方法的声明

             权限修饰符 返回值类型 方法名(形参列表){
                      方法体
              }
  注意：static、final；abstract 来修饰的方法，后面再讲。

3.说明：现阶段学习先默认方法的使用权限都使用public

①关于权限修饰符
       java规定的4种权限修饰符：private、public、缺省、protected  -->封装性再细说
②返回值类型：有返回值 VS 没有返回值
     (1)如果方法中有返回值，则必须在方法声明时，指定返回值的类型。同时，方法中需要使用return关键字来返回指定类型的变量或常量。
     如果方法没有返回值，则方法声明时，使用void来表示。通常，没有返回值的方法中，就不使用return。但如果使用的话，只能"return;"表示结束此方法的意思。
     (2)定义方法该不该有返回值？        ①题目要求      ②凭经验：具体问题具体分析
③方法名：属于标识符，遵循标识符的规则和规范，“见名知义”
④形参列表：方法可以声明0个、1个，或多个形参
      (1)格式：数据类型1 形参1，数据类型2 形参2，·····
      (2)定义方法时，该不该定义形参？           ①题目要求      ②凭经验：具体问题具体分析

⑤方法体：方法功能的体现。

注意：

<1>方法被调用一次，就会执行一次

<2>没有具体返回值的情况，返回值类型用关键字void表示，那么方法体中可以不必使用return语句。如果使用，仅用来结束方法。

<3>定义方法时，方法的结果应该返回给调用者，交由调用者处理。

<4>方法中只能调用方法或属性，不可以在方法内部定义方法。

4.return关键字的使用

  (1)使用范围：使用在方法体中
  (2)作用：①结束方法        ②针对于有返回值类型的方法，使用“return 数据”方法返回所要的数据。
  (3)return关键字后面不可以声明执行语句。

5.方法的使用

        可以调用当前类的属性或方法。        方法中，不可以定义方法。

       特殊地：方法A中又调用了方法A  称之为：递归方法

public class CustomerTest {
	public static void main(String[] args) {
		
		Customer cust1 = new Customer();
		
		cust1.eat();
		
		//测试形参是否需要设置的问题
//		int[] arr = new int[] {3,4,5,2,9};
//		cust1.sort();
		
		cust1.sleep(8);
	}
}

//客户类
class Customer{
	
	//属性
	String name;
	int age;
	boolean isMale;
	
	//方法
	public void eat() {
		System.out.println("客户吃饭");
		return;
		//return后不可以声明表达式
		//System.out.println("hello");
	}
	
	public void sleep(int hour) {
		System.out.println("休息了" + hour + "个小时");
		eat();
	}
	
	public String getName() {
		if(age > 18) {
			return name;
		}else {
			return "Tom";
		}	
	}
	
	public String getNation(String nation) {
		String info = "我的国籍是：" + nation;
		return info;
	}
	
	//体会形参是否需要设置的问题
//	public void sort(int[] arr) {
//		
//	}
//	public void sort() {
//		int[] arr = new int[] {3,4,2,6,9,8}
//	}
	
	//错误的
	/*public void info() {
		public void swim() {
			
		}
	}*/
}

6.理解“万事万物皆对象

  1.在java语言范畴中，我们都将功能、结构等封装到类中，通过类的实例化，来调用具体的功能结构
          >Scanner,String等
          >文件：File
          >网络资源：URL
  2.涉及到java语言与前段HTML、后端的数据库交互时，前后端的结构在java层面交互时，都体现为类、对象。

7.内存解析的说明

        引用数据的类型，只可能存储两类值：null 或地址值(含变量的类型)

8.匿名对象的使用

  1.理解：我们创建的对象，没有显式的赋给一个变量名。即为匿名对象
  2.特征：匿名对象只能调用一次。
  3.使用：如下

public class InstanceTest {
	public static void main(String[] args) {
		Phone p = new Phone();
//		p = null;
		System.out.println(p);
		
		p.sendEmail();
		p.playGame();
		
		//匿名对象
//		new Phone().sendEmail();
//		new Phone().playGame();
		
		new Phone().price = 1999;
		new Phone().showPrice();//0.0
		
		//*******************
		PhoneMall mall = new PhoneMall();
//		mall.show(p);
		//匿名对象的使用
		mall.show(new Phone());
	}
}


class PhoneMall{
	
	public void show(Phone phone) {
		phone.sendEmail();
		phone.playGame();
	}
}


class Phone{
	double price;//价格
	
	public void sendEmail() {
		System.out.println("发送邮件");
	}
	
	public void playGame() {
		System.out.println("玩游戏");
	}
	
	public void showPrice() {
		System.out.println("手机价格为：" + price);
	}
}

9.自定义数组的工具类

10.方法的重载(overload) loading...

1.重载的定义：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。    “两同一不同”：同一个类、相同方法名        参数列表不同：参数个数不同、参数类型不同

2.重载的特点：与返回值类型无关，只看参数列表，且参数列表必须不同（参数个数或参数类型）。调用时，根据方法参数列表的不同来区别。

3.举例

Arrays类中重载的sort() / binarySearch()

  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;}//返回两个小数的和

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

11.可变个数形参的方法

1.jdk5.0新增的内容
2.具体使用：
      ①可变个数的格式：数据类型 ... 变量名
      ②当调用可变个数形参的方法时，传入的参数个数可以是：0个、1个、2个、...
      ③可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载
      ④可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间不构成重载。换句话说，二者不能共存。
      ⑤可变个数形参在方法的形参中，必须声明在末尾
      ⑥可变个数形参在方法的形参中，最多只能声明一个可变形参。

12.变量的赋值

   如果变量是基本数据类型，此时赋值的是变量所保存的数据值。
   如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值。

13.方法的形参的传递机制：值传递

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

        形参：方法定义时，声明的小括号内的参数
        实参：方法调用时，实际传递给形参的数据
    
2.值传递机制（即将实际参数值的副本（复制品）传入方法内，而参数本身不受影响）
        如果参数是基本数据类型，此时实参数给形参的是实参真实存储的数据值。
        如果参数是引用数据类型，此时实参赋给形参的是实参存储数据的地址值。

例题：方法的参数传递 15、0、20

14.递归方法的使用(了解)

1.递归方法：一个方法体内调用它自身
        方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无须循环控制。
       递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环。

四、面向对象的特征一：封装性  

1.问题的引入

      当我们创建一个类的对象以后，我们可以通过“对象.属性”的方式，对对象的属性进行赋值。这里，赋值操作要受到属性的数据类型和存储范围的制约。但除此之外，没有其他制约条件。
     但是，在实际问题中，我们往往需要给属性赋值，加入额外的限制条件。这个条件就不能在属性声明时体现，我们只能通过方法进行限制条件的添加。(比如setLegs())
      同时，我们需要避免用户再使用“对象.属性”的方式对属性进行赋值。则需要将属性声明为私有的(private)  --> 此时，针对于属性就体现了封装性。

2.封装性的体现

    我们将类的属性xxx私有化(private)，同时，提供公共的(public)方法来获取(getXxx)和设置(setXxx)此属性的值
          拓展：封装性的体现：①如上     ②不对外暴露的私有方法  ③单例模式 ...

3.封装性的体现，需要权限修饰符来配合

  1. java规定的4种权限（从小到大排列）：private、缺省、protected、public
  2. 4种权限可以用来修饰类及类的内部结构：属性、方法、构造器、内部类    修饰类的话，只能使用：缺省、public
      总结：java提供的4种权限修饰符来修饰类及类的内部结构，体现类及类的内部结构在被调用时的可见性的大小。

五、类的结构之三：构造器(或构造方法、constructor)的使用

（1）构造器的作用

  1.创建对象        2.初始化对象的信息

（2）说明

  1.如果没有显式的定义类的构造器的话，则系统默认提供一个空参的构造器。
  2.定义构造器的格式：权限修饰符 类名(形参列表){}
  3.一个类中定义的多个构造器，彼此构成重载
  4.一旦显式的定义了类的构造器之后，系统就不再提供默认的空参构造器
  5.一个类中，至少会有一个构造器。

1.属性赋值的先后顺序

  ① 默认初始化
  ② 显式初始化
  ③ 构造器中初始化
  ④ 通过“对象.方法”或“对象.属性”的方式赋值
  以上操作的先后顺序：① - ② - ③ - ④

2.JavaBean

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

六、UML类图

七、this关键字的使用

1.this可以用来修饰、调用：属性、方法、构造器

2.this修饰属性和方法                this理解为：当前对象 或 当前正在创建的对象
（1）在类的方法中，我们可以使用“this.属性”或“this.方法”的方式，调用当前对象属性或方法。但通常情况下，我们都选择省略"this."。特殊情况：若方法的形参和类的属性同名时，我们必须显式的使用"this.变量"的方式，表明此变量是属性，而非形参。
（2）在类的构造器中，我们可以使用“this.属性”或“this.方法”的方式，调用当前正在创建的对象属性或方法。但通常情况下，我们都选择省略"this."。特殊情况：若方法的形参和类的属性同名时， 我们必须显式的使用"this.变量"的方式，表明此变量是属性，而非形参。

3.this构造器

      ①我们在类的构造器中，可以显式的使用"this(形参列表)"方式，调用本类中指定的其他构造器
      ②构造器中不能通过"this(形参列表)"方式调用自己
      ③如果一个类中有n个构造器，则最多有n - 1个构造器使用了"this(形参列表)"
      ④规定："this(形参列表)"必须声明在当前构造器的首行
      ⑤构造器内部，最多只能声明一个"this(形参列表)"，用来调用其他的构造器

八、package关键字的使用

1.关键字package

  1.为了更好的实现项目中类的管理，提供包的概念
  2.使用package声明类或接口所属的包，声明在源文件的首行
  3.包，属于标识符，遵循标识符的命名规则、规范(xxxyyyzzz)、"见名知义"
  4.每"."一次，就代表一层文件目录。
      补充：同一个包下，不能命名同名的接口、类。
                 不同的包下，可以命名同名的接口、类。

JDK中主要的包介绍

2.关键字import

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

九、MVC设计模式