面向对象上（重点）

关键字this:

关键字：this


1.this可以理解为：
当前对象 或 当前正在创建的对象
2.可以调用的结构：属性、方法、构造器
3.this调用属性、方法：
在方法中：我们可以在方法中通过"this.属性"或者"this.方法"的方法，表示调用当前对象的指定属性或方法。但是通常情况下，我们都省略了"this."。但是如果方法的形参和当前对象的属性名相同的情况下，我们必须显式的使用"this.变量"的方式，表明此变量是属性，而非形参。
 * 
在构造器中：我们可以在构造器中通过"this.属性"或者"this.方法"的方法，表示调用当前正在创建的对象的指定属性或方法。但是通常情况下，我们都省略了"this."。但是如果构造器的形参和当前正在创建的对象的属性名相同的情况下，我们必须显式的使用"this.变量"的方式，表明此变量是属性，而非形参。


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

二构造器：

1.构造器（或构造方法：constructor.
构造器的作用：① 创建类的对象  ② 初始化对象的属性


2.使用说明：
 * ①如果在定义一个类时，没有显式的声明类的构造器。那么系统会自动给类提供一个无参的构造器。
 * ②如何声明一个类的构造器。格式：权限修饰符  类名(形参列表){  }
 * ③如果我们在类中一旦定义类的构造器，那么系统就不再提供默认的无参的构造器了。
 * ④类的多个构造器之间，彼此构成重载
 * ⑤总结：类中，一定会有构造器！

属性赋值顺序：

给类的属性赋值的先后顺序为：
①默认初始化 - ②显式初始化 - ③构造器中初始化 - ④通过"对象.属性" 或 "对象.方法"的方法，给属性赋值

类的结构之二：方法


类的设计中，两个重要结构之二：方法
 0.方法：类中声明的一个结构，能够实现具体功能。 比如：Arrays.sort(int[] arr) /int Arrays.binarySearch(int[] arr,int value)
 * 
 * 1.举例：
 *     public void eat(String food){}
 *     public void show(){}
 *     public int returnAge(){}
 *     public String info(String nation,String color){}
 *     
 * 2. 方法声明的格式：
 *     权限修饰符  返回值类型  方法名(形参列表){
 * 方法体
 *    }
 *    
 * 3.具体说明：
 * 1权限修饰符：可以理解为所被修饰的结构能被调用的范围的大小。
 *        如下的权限修饰符：public  protected  缺省   private.
 *        目前，大家如果声明方法，可以先都是用public
 *      2关于返回值类型：没返回值：void
 *                     返回值：指明具体的返回值的类型。
 *        如果方法声明时，返回值，那么我们就需要在方法体执行中，返回具体的满足相应类型的变量或常量。
 *        比如：return 1 或 return index;
 *        说明：如果方法返回值，方法体中一定有return！
 *      3方法名，属于标识符。需要命名时，满足标识符的命名规则和规范，"见名知意".
 *        println() / sort() / binarySearch() / random() / sqrt() / equals()
 *        
 *      4形参列表：可以声明0个，1个或多个变量。如果声明了多个变量，中间用","隔开
 *      5方法体：我们调用方法时，要执行的逻辑。
 *         方法的功能，主要体现在方法体上。
 *
 * 4. 1方法中调用当前类的属性或方法。  （如果方法A中调用方法A:递归方法
 *    2在方法体中，可以使用关键字：return。 return的意思：返回、跳出。
 *      return 语句后面，不能执行语句的。
 *    3在方法内，不能再定义方法。

java的值传递机制


1.针对于方法内变量的赋值举例：
int m = 10;
int n = m;

m = 20;

System.out.println("------------------");

Order o1 = new Order();
o1.orderId = 1001;

Order o2 = o1;//o1,o2就同时指向堆空间中创建的同一个对象实体
System.out.println(o2.orderId);//1001
o2.orderId = 1002;
System.out.println(o1.orderId);//1002


2.针对于方法的参数概念
形参：方法在声明时，指明的参数。
实参：方法在被调用时，具体给形参赋的值，就是实参。


3.java中参数传递机制：值传递
规则：
如果方法的形参是基本数据类型的变量，则方法调用时，传递的实参即为基本数据类型变量所保存的具体的数值。
如果方法的形参是引用数据类型的变量，则方法调用时，传递的实参即为引用数据类型变量所保存的地址值。
推广：
如果赋值的基本数据类型的变量，则传递的是基本数据类型变量所保存的具体的数值。
如果赋值的引用数据类型的变量，则传递的是引用数据类型变量所保存的地址值。
4.典型例题与内存解析：
【例题1】

内存解析（重点）


【例题2】

递归方法


1.定义：一个方法体内调用它自身。


2.如何理解递归方法？
2.1 方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无须循环控制。
2.2 递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环。
3.举例：
//练习1：请用Java写出递归求阶乘(n!)的算法
public int mul(int num){
if(num == 1){
return 1;
}else{
return num * mul(num - 1);
}

}

//练习2：已知一个数列：f(0) = 1,f(1) = 4,f(n+2)=2*f(n+1) + f(n),其中n是大于0的整数，求f(10)的值。
public int func(int num){
if(num == 0){
return 1;
}else if(num == 1){
return 4;
}else{
//正确的写法
return 2 * func(num - 1) + func(num - 2);
//错误的写法
// return func(num + 2) - 2 * func(num + 1);
}
}

方法的重载


1.方法的重载的概念
在同一类中，相同的方法名，不同的参数列表的方法之间，彼此构成重载！
总结："两同一不同". 一不同：①参数个数不同 ② 参数类型不同


2.
构成重载的举例：
    //如下的四个方法构成重载
public void getSum(int i,int j){
System.out.println(i + j);
}

public void getSum(float f1,float f2){
System.out.println(f1 + f2);
}

public void getSum(String s1,String s2){
System.out.println(s1 + s2);
}

public double getSum(double d1,double d2){
return d1 + d2;
}




不构成重载的举例：
//与上面4个方法不能构成重载
// public void getSum(int m,int n){
// System.out.println(m - n);
// }

// public int getSum(int i,int j){
// return i + j;
// }




3.如何确定类中某一个方法的调用：
指明方法名--->指明参数的类型

可变个数形参的方法


1.使用说明：jdk5.0新特性 
 * 1.可变个数形参的格式：数据类型 ... 变量名
 * 2.可变个数形参的方法在调用时，给可变个数的形参赋值时，可以赋值的个数为：0个，1个，。。。。
 * 3.可变个数形参的方法与同名的方法之间，彼此构成重载
 * 4.可变个数形参的方法与形参类型相同的数组的方法不能同时出现在类中。
 * 5.可变个数形参必须声明为方法形参的最后一个参数。
 * 6.在一个方法的形参位置，最多只能声明一个可变个数形参


2.举例说明：
    public void show(int i) {
System.out.println(i);
}


public void show(String s) {
System.out.println(s);
}


// 可变个数形参的方法
public void show(String ... strs) {
System.out.println("哈哈！");
for(int i = 0;i < strs.length;i++){
System.out.println(strs[i]);
}
}
//不能再声明了。
// public void show(String[] strs){
//
// }


public void show(int i,String... strs) {


}


调用时：
m.show();
m.show("AA");
m.show("AA","BB");
m.show(new String[]{"AA","BB"});

类的结构之一：属性


类的设计中，两个重要结构之一：属性
成员变量(或属性)   vs 局部变量
 * 1.相同点：① 声明的格式是相同的：数据类型 变量名 = 初始化值
 * ② 先声明，后使用
 * ③ 变量都作用域。
 * 
 *         2.不同点：①类中声明的位置的不同。
 *       成员变量：在类的一对{}内直接声明的变量
 *       局部变量：方法内声明的，方法的形参位置声明的，构造器内声明的，代码块内声明的都是局部变量。
 *      
 *              ②成员变量可以在数据类型前声明权限修饰符，而局部变量是不可以声明权限修饰符的。
 *              补充：权限修饰符哪些？public 、 private 、 protected、缺省
 *              
 *              ③成员变量：声明时，默认初始化值。也就是说，我们在定义成员变量时，可以不显式的赋值。
 *               整型：byte、short 、 int 、 long ：0
 *                  浮点型：float 、 double : 0.0
 *                  字符型：char：0 （或表示为'\u0000'
 *                  布尔型：boolean : false
 *                  
 *                  引用数据类型：null
 *               局部变量：没默认初始化值。必须在调用前，显式的赋值
 *               特别的：方法的形参。此局部变量在方法内调用前，不需要赋值。它的赋值，是在方法调用时进行的。
 *              
 *              ④ 二者在内存中存放的位置，是不同的。
 *                成员变量：存放在堆空间中
 *                局部变量：存放在栈空间中
 *              
 * 
 * 回忆：变量的分类：照数据类型分类：基本数据类型(8个)  vs 引用数据类型(3个:数组、类、接口)
 *                   照变量在类中声明的位置的不同：成员变量(或属性)   vs 局部变量

成员变量与局部变量的内存分析（重点）

类与对象


1.面向对象学习的条主线：
 * 1.java类及类的成员：属性、方法、构造器；代码块、内部类
 * 2.面向对象的个特征：封装性、继承性、多态性、(抽象性)
 * 3.其它关键字的使用：this、super、abstract、interface、import、package、static、final等


2.面向对象与面向过程（理解
概念对比：面向过程，强调的是功能行为。面向对象，将功能封装进对象，强调具备了功能的对象。
举例：人打开门；人把大象装进冰箱。


3.完成一个项目（或功能）的思路：比如要求从键盘获取一个String的功能
1)是否已经存在一个具体此功能的对象，如果存在，则直接调用此对象的功能。（scanner.next()
2)如果不存在具此功能的对象，我们就需要自己创建一个此对象。(Scanner s = new Scanner(System.in)
3)如果创建此对象对应的类不存在，那就需要我们自己创建一个具有此功能的类。


4.面向对象中两个重要的概念：
类(class) 与  对象(object、instance)
类：对一类事物的描述，是抽象的、概念上的定义
对象：是是实实在在存在的一个个体，是具体的。


二者的关系：对象是由类派生的。


5.面向对象思想落地实现的规则一
 * 1.创建类，即为提供类的内部结构：属性和方法
 * 2.创建类的对象 （类的实例化，实例化类)
 * 3.可以通过"对象.属性"或"对象.方法"调用相关的功能
补充：几个概念的使用说明
1.创建类的对象=类的实例化=实例化类
2.属性=成员变量=field=域=字段
3.方法=成员方法=成员函数=method


6.对象的创建与对象的内存解析




7.匿名对象:创建了类的对象，但是并没声明给一个对象引用。
特点：匿名对象只能被调用一次。
举例：
//匿名对象的创建和使用
new Phone().sendEmail();//匿名对象1

new Phone().call();//匿名对象2
 
应用：常常在调用方法时，将一个匿名对象作为参数传递过去。
//*****应用场景*********
PhoneFactory factory = new PhoneFactory();
factory.display(new Phone());
其中：
class PhoneFactory{

public void display(Phone phone){
phone.call();
phone.sendEmail();
}

}
对象的内存分析（重点）

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


1.面向对象的特征一：封装与隐藏
问题引入： 
我们在创建了一个类的对象以后，通过"对象.属性"的方式，可以给对象的属性赋值。对此属性的赋值，是限制的，比如：数据类型和数据类型储值范围的限制。但是，在实际问题中，还通过需要额外的限制。同时这些额外的限制，不可能在属性的声明中加上限制逻辑。那么，我们只能考虑通过方法，对属性的赋值进行额外的限制。同时，我们必须禁止再直接通过"对象.属性"的方式，对属性进行赋值。


2.封装性思想具体的代码体现：
体现一：私化（private类的属性xxx，同时，提供公共的（public设置(setXxx())和获取(getXxx())的方法。
体现二：如果类中的方法，不希望在类外被调用，我们可以设置为private的。
体现：如果类A不希望在本包之外被调用，那么可以将此类A声明为缺省的。
体现四：单例模式


3.java规定的四种权限修饰符---广义上封装性的体现
3.1 权限从小到大顺序为：private < 缺省  < protected < public
3.2 具体的修饰范围：


3.3 权限修饰符可用来修饰的结构说明：
① 4种权限都可以用来修饰类的内部结构：属性、方法、构造器、内部类。
② 只能使用缺省 或者 public 来修饰类