面向对象1

面向对象

程序员从面向过程的执行者转化成了面向对象的指挥者

对象的内存分析：

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

局部变量和成员变量

/*
 * 类中属性的使用
 *
 * 属性（成员变量）   vs  局部变量
 * 1.相同点：
 *        1.1  定义变量的格式：数据类型  变量名 = 变量值
 *        1.2 先声明，后使用
 *        1.3 变量都有其对应的作用域
 *
 *
 * 2.不同点：
 *        2.1 在类中声明的位置的不同
 *        属性：直接定义在类的一对{}内
 *        局部变量：声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量
 *
 *        2.2 关于权限修饰符的不同
 *        属性：可以在声明属性时，指明其权限，使用权限修饰符。
 *           常用的权限修饰符：private、public、缺省、protected  --->封装性
 *           目前，大家声明属性时，都使用缺省就可以了。
 *        局部变量：不可以使用权限修饰符。
 *
 *        2.3 默认初始化值的情况：
 *        属性：类的属性，根据其类型，都有默认初始化值。
 *           整型（byte、short、int、long）：0
 *           浮点型（float、double）：0.0
 *           字符型（char）：0  （或'\u0000'）
 *           布尔型（boolean）：false
 *
 *           引用数据类型（类、数组、接口）：null
 *
 *        局部变量：没有默认初始化值。
 *        意味着，我们在调用局部变量之前，一定要显式赋值。
 *           特别地：形参在调用时，我们赋值即可。
 *
 *        2.4 在内存中加载的位置：
 *        属性：加载到堆空间中   （非static，static的属性放到了方法区）
 *        局部变量：加载到栈空间
 *
 */

类中方法的声明和使用

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

方法的声明：权限修饰符返回值类型方法名(形参列表){

方法体

}

注意：static、final、abstract 来修饰的方法，后面再讲。

说明：

3.1 关于权限修饰符：默认方法的权限修饰符先都使用public
Java规定的4种权限修饰符：private、public、缺省、protected -->封装性再细说

3.2 返回值类型：有返回值 vs 没有返回值
3.2.1 如果方法有返回值，则必须在方法声明时，指定返回值的类型。同时，方法中，需要使用
return关键字来返回指定类型的变量或常量：“return 数据”。
如果方法没有返回值，则方法声明时，使用void来表示。通常，没有返回值的方法中，就不需要
使用return.但是，如果使用的话，只能“return;”表示结束此方法的意思。
```
 3.2.2 我们定义方法该不该有返回值？
 	① 题目要求
 	② 凭经验：具体问题具体分析
```

3.3 方法名：属于标识符，遵循标识符的规则和规范，“见名知意”

3.4 形参列表：方法可以声明0个，1个，或多个形参。
3.4.1 格式：数据类型1 形参1,数据类型2 形参2,...
3.4.2 我们定义方法时，该不该定义形参？
① 题目要求
② 凭经验：具体问题具体分析

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

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

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

java内存解析

虚拟机栈：存放局部变量储存在栈结构中。

堆：类的属性（非static)

方法区：类的信息，常量池，静态域。

方法的重载(overload)

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

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

重载示例：

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

可变个数的形参

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个或多个
可变个数形参的方法与同名的方法之间，彼此构成重载
可变参数方法的使用与方法参数部分使用数组是一致的
方法的参数部分有可变形参，需要放在形参声明的最后
在一个方法的形参位置，最多只能声明一个可变个数形参

关于变量的赋值

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

代码演示：

package com.atguigu.java1;
/*
 * 关于变量的赋值：
 *  如果变量是基本数据类型，此时赋值的是变量所保存的数据值。
 *  如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值。
 */
public class ValueTransferTest {
	public static void main(String[] args) {
		System.out.println("***********基本数据类型：****************");
		int m = 10;
		int n = m;
		System.out.println("m = " + m + ", n = " + n);
		n = 20;
		System.out.println("m = " + m + ", n = " + n);
		System.out.println("***********引用数据类型：****************");
		Order o1 = new Order();
		o1.orderId = 1001;
		Order o2 = o1;//赋值以后，o1和o2的地址值相同，都指向了堆空间中同一个对象实体。
		System.out.println("o1.orderId = " + o1.orderId + ",o2.orderId = " +o2.orderId);
		o2.orderId = 1002;
		System.out.println("o1.orderId = " + o1.orderId + ",o2.orderId = " +o2.orderId);
	}
}
class Order{
	int orderId;
}

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

方法的形参的传递机制：值传递
1.形参：方法定义时，声明的小括号内的参数
实参：方法调用时，实际传递给形参的数据
2.值传递机制：
如果参数是基本数据类型，此时实参赋给形参的是实参真实存储的数据值。
如果参数是引用数据类型，此时实参赋给形参的是实参存储数据的地址值。

代码如下：下面的代码可以使用方法中的局部变量在栈中来解释。两个方法有两个栈帧，相互没有干涉。所以互不影响。

public class ValueTransferTest1 {
   public static void main(String[] args) {
      
      int m = 10;
      int n = 20;
      
      System.out.println("m = " + m + ", n = " + n);
      //交换两个变量的值的操作
//    int temp = m ;
//    m = n;
//    n = temp;
      
      ValueTransferTest1 test = new ValueTransferTest1();
      test.swap(m, n);
      System.out.println("m = " + m + ", n = " + n);
      
   }
   
   public void swap(int m,int n){
      int temp = m ;
      m = n;
      n = temp;
   }
   public void swap1(Integer m,Integer n){//调用这个方法也不行啊。不理解啊。
      Integer temp = m ;
      m = n;
      n = temp;
   }
}

这里有我自己的一点小疑问：就是把swap里的int换成integer，但是还是并不行。看了网上的说明，还是不理解。

https://zhuanlan.zhihu.com/p/140720463

递归(recursion)方法

package com.atguigu.java2;

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

	public static void main(String[] args) {

		// 例1：计算1-100之间所有自然数的和
		// 方式一：
		int sum = 0;
		for (int i = 1; i <= 100; i++) {
			sum += i;
		}
		System.out.println(sum);
		// 方式二：
		RecursionTest test = new RecursionTest();
		int sum1 = test.getSum(100);
		System.out.println(sum1);
		
		System.out.println("*****************");
		int value = test.f(10);
		System.out.println(value);

	}

	// 例1：计算1-n之间所有自然数的和
	public int getSum(int n) {// 3

		if (n == 1) {
			return 1;
		} else {
			return n + getSum(n - 1);
		}

	}

	// 例2：计算1-n之间所有自然数的乘积:n!
	public int getSum1(int n) {

		if (n == 1) {
			return 1;
		} else {
			return n * getSum1(n - 1);
		}

	}
	
	//例3：已知有一个数列：f(0) = 1,f(1) = 4,f(n+2)=2*f(n+1) + f(n),
	//其中n是大于0的整数，求f(10)的值。
	public int f(int n){
		if(n == 0){
			return 1;
		}else if(n == 1){
			return 4;
		}else{
//			return f(n + 2) - 2 * f(n + 1);
			return 2*f(n - 1) + f(n - 2);
		}
	}

	//例4：斐波那契数列
	
	//例5：汉诺塔问题
	
	//例6：快排

}

面向对象特征之一：封装

封装的目的：高内聚，低耦合

封装的手段是四个权限修饰符

四种访问权限修饰符

四种权限修饰符对于类成员的限定：

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

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

对于类的限定：

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

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

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

构造器

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

构造器的作用

创建对象

给对象进行初始化，给对象的属性赋值。

注意事项：

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

需要补充

super关键字

super关键字的使用
1.super理解为：父类的
2.super可以用来调用：属性、方法、构造器

3.super的使用：调用属性和方法

3.1 我们可以在子类的方法或构造器中。通过使用"super.属性"或"super.方法"的方式，显式的调用
父类中声明的属性或方法。但是，通常情况下，我们习惯省略"super."
3.2 特殊情况：当子类和父类中定义了同名的属性时，我们要想在子类中调用父类中声明的属性，则必须显式的
使用"super.属性"的方式，表明调用的是父类中声明的属性。
3.3 特殊情况：当子类重写了父类中的方法以后，我们想在子类的方法中调用父类中被重写的方法时，则必须显式的
使用"super.方法"的方式，表明调用的是父类中被重写的方法。

4.super调用构造器
4.1 我们可以在子类的构造器中显式的使用"super(形参列表)"的方式，调用父类中声明的指定的构造器
4.2 "super(形参列表)"的使用，必须声明在子类构造器的首行！
4.3 我们在类的构造器中，针对于"this(形参列表)"或"super(形参列表)"只能二选一，不能同时出现
4.4 在构造器的首行，没有显式的声明"this(形参列表)"或"super(形参列表)"，则默认调用的是父类中空参的构造器：super()
4.5 在类的多个构造器中，至少有一个类的构造器中使用了"super(形参列表)"，调用父类中的构造器

子类对象实例化的全过程

从结果上来看：（继承性）
子类继承父类以后，就获取了父类中声明的属性或方法。
创建子类的对象，在堆空间中，就会加载所有父类中声明的属性。
从过程上来看：
当我们通过子类的构造器创建子类对象时，我们一定会直接或间接的调用其父类的构造器，进而调用父类的父类的构造器，...
直到调用了java.lang.Object类中空参的构造器为止。正因为加载过所有的父类的结构，所以才可以看到内存中有
父类中的结构，子类对象才可以考虑进行调用。

明确：虽然创建子类对象时，调用了父类的构造器，但是自始至终就创建过一个对象，即为new的子类对象。

面向对象特征之三：多态性

面向对象特征之三：多态性
1.理解多态性：可以理解为一个事物的多种形态。
2.何为多态性：
对象的多态性：父类的引用指向子类的对象（或子类的对象赋给父类的引用）

多态的使用：虚拟方法调用
有了对象的多态性以后，我们在编译期，只能调用父类中声明的方法，但在运行期，我们实际执行的是子类重写父类的方法。
总结：编译，看左边；运行，看右边。

4.多态性的使用前提： ① 类的继承关系 ② 方法的重写
5.对象的多态性，只适用于方法，不适用于属性（编译和运行都看左边）

重载和重写的区别

重载，是指允许存在多个同名方法，而这些方法的参数不同。编译器根据方法不同的参数表，对同名方法的名称做修饰。对于编译器而言，这些同名方法就成了不同的方法。它们的调用地址在编译期就绑定了。Java的重载是可以包括父类和子类的，即子类可以重载父类的同名不同参数的方法。所以：对于重载而言，在方法调用之前，编译器就已经确定了所要调用的方法，这称为“早绑定”或“静态绑定”；而对于多态，只有等到方法调用的那一刻，解释运行器才会确定所要调用的具体方法，这称为“晚绑定”或“动态绑定”。引用一句Bruce Eckel的话：“不要犯傻，如果它不是晚绑定，它就不是多态。”

instanceof 操作符

x instanceof A：检验x是否为类A的对象，返回值为boolean型。

要求x所属的类与类A必须是子类和父类的关系，否则编译错误。

如果x属于类A的子类B，x instanceof A值也为true。

instanceof关键字的使用
a instanceof A:判断对象a是否是类A的实例。如果是，返回true；如果不是，返回false。
使用情境：为了避免在向下转型时出现ClassCastException的异常，我们在向下转型之前，先
进行instanceof的判断，一旦返回true，就进行向下转型。如果返回false，不进行向下转型。

如果 a instanceof A返回true,则 a instanceof B也返回true.
其中，类B是类A的父类。

对象类型转换 (Casting )

基本数据类型的Casting：

自动类型转换：小的数据类型可以自动转换成大的数据类型如long g=20; double d=12.0f

强制类型转换：可以把大的数据类型强制转换(casting)成小的数据类型如 float f=(float)12.0; int a=(int)1200L

对Java对象的强制类型转换称为造型

从子类到父类的类型转换可以自动进行

从父类到子类的类型转换必须通过造型(强制类型转换)实现

无继承关系的引用类型间的转换是非法的

在造型前可以使用instanceof操作符测试一个对象的类型

Object类

面试题： == 和 equals() 区别
一、回顾 == 的使用：
== ：运算符

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

{
		//基本数据类型
		int i = 10;
		int j = 10;
		double d = 10.0;
		System.out.println(i == j);//true
		System.out.println(i == d);//true
		boolean b = true;
//		System.out.println(i == b);
		char c = 10;
		System.out.println(i == c);//true
		char c1 = 'A';
		char c2 = 65;
		System.out.println(c1 == c2);//true
		//引用类型：
		Customer cust1 = new Customer("Tom",21);
		Customer cust2 = new Customer("Tom",21);
		System.out.println(cust1 == cust2);//false
		String str1 = new String("atguigu");
		String str2 = new String("atguigu");
		System.out.println(str1 == str2);//false
		System.out.println("****************************");
		System.out.println(cust1.equals(cust2));//false--->true
		System.out.println(str1.equals(str2));//true
		Date date1 = new Date(32432525324L);
		Date date2 = new Date(32432525324L);
		System.out.println(date1.equals(date2));//true	
	}

equals()方法的使用：

是一个方法，而非运算符
只能适用于引用数据类型
Object类中equals()的定义：
public boolean equals(Object obj) {
return (this == obj);
}
说明：Object类中定义的equals()和==的作用是相同的：比较两个对象的地址值是否相同.即两个引用是否指向同一个对象实体
像String、Date、File、包装类等都重写了Object类中的equals()方法。重写以后，比较的不是两个引用的地址是否相同，而是比较两个对象的"实体内容"是否相同。
通常情况下，我们自定义的类如果使用equals()的话，也通常是比较两个对象的"实体内容"是否相同。那么，我们就需要对Object类中的equals()进行重写.
重写的原则：比较两个对象的实体内容是否相同.

Object类是所有Java类的根父类
如果在类的声明中未使用extends关键字指明其父类，则默认父类为java.lang.Object类

toString() 方法

Object类中toString()的使用：

当我们输出一个对象的引用时，实际上就是调用当前对象的toString()
Object类中toString()的定义：
public String toString() {
return getClass().getName() + "@" + Integer.toHexString(hashCode());
}
像String、Date、File、包装类等都重写了Object类中的toString()方法。使得在调用对象的toString()时，返回"实体内容"信息
自定义类也可以重写toString()方法，当调用此方法时，返回对象的"实体内容"

基本类型、包装类与String类间的转换

基本数据类型和包装类之间在jdk5.0之后都是自动拆装箱的。可以直接赋值。其实也就是说基本类型和包装类型在操作上是没有区别的。

String类型和基本类型（包装类型）之间的转换。

调用String的valueOf(Xxx xxx)

        int num2 = Integer.parseInt(str1); //123
        Integer num3 = Integer.parseInt(str1);  //123
        String str2 = "true";
        String str3 = "trUe";
        boolean b1 = Boolean.parseBoolean(str2);//true
        boolean b3 = Boolean.parseBoolean(str3);//true
        
        
        @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);//"12.4"
        System.out.println(str2);//"12.3"
        System.out.println(str3);//"12.4"
    }

关键知识点：

@Test
public void test3() {
    Integer i = new Integer(1);
    Integer j = new Integer(1);
    System.out.println(i == j);//false

    //Integer内部定义了IntegerCache结构，IntegerCache中定义了Integer[],
    //保存了从-128~127范围的整数。如果我们使用自动装箱的方式，给Integer赋值的范围在
    //-128~127范围内时，可以直接使用数组中的元素，不用再去new了。目的：提高效率

    Integer m = 1;
    Integer n = 1;
    System.out.println(m == n);//true

    Float f = 2.3f;
    Float g = 2.3f;
    System.out.println("f==g" + (f == g));

    Integer x = 128;//相当于new了一个Integer对象
    Integer y = 128;//相当于new了一个Integer对象
    System.out.println(x == y);//false
}

static关键字的使用

static关键字的使用
1.static:静态的
2.static可以用来修饰：属性、方法、代码块、内部类
3.使用static修饰属性：静态变量（或类变量）
      3.1 属性，按是否使用static修饰，又分为：静态属性  vs 非静态属性(实例变量)
         实例变量：我们创建了类的多个对象，每个对象都独立的拥有一套类中的非静态属性。当修改其中一个对象中的
             非静态属性时，不会导致其他对象中同样的属性值的修改。
      静态变量：我们创建了类的多个对象，多个对象共享同一个静态变量。当通过某一个对象修改静态变量时，会导致
             其他对象调用此静态变量时，是修改过了的。
      3.2 static修饰属性的其他说明：
         ① 静态变量随着类的加载而加载。可以通过"类.静态变量"的方式进行调用
         ② 静态变量的加载要早于对象的创建。
         ③ 由于类只会加载一次，则静态变量在内存中也只会存在一份：存在方法区的静态域中。
         
         ④    类变量    实例变量
         类    yes       no
         对象       yes       yes
         
     3.3 静态属性举例：System.out; Math.PI;
4.使用static修饰方法：静态方法
      ① 随着类的加载而加载，可以通过"类.静态方法"的方式进行调用
      ②        静态方法   非静态方法
         类    yes       no
         对象       yes       yes
      ③ 静态方法中，只能调用静态的方法或属性
       非静态方法中，既可以调用非静态的方法或属性，也可以调用静态的方法或属性
5. static注意点：
   5.1 在静态的方法内，不能使用this关键字、super关键字
   5.2 关于静态属性和静态方法的使用，大家都从生命周期的角度去理解。
   
6. 开发中，如何确定一个属性是否要声明为static的？
      > 属性是可以被多个对象所共享的，不会随着对象的不同而不同的。
      > 类中的常量也常常声明为static
   开发中，如何确定一个方法是否要声明为static的？
       > 操作静态属性的方法，通常设置为static的
     > 工具类中的方法，习惯上声明为static的。 比如：Math、Arrays、Collections

设计模式

单例设计模式

单例设计模式：

所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例。
如何实现？
饿汉式 vs 懒汉式
区分饿汉式和懒汉式
饿汉式：
坏处：对象加载时间过长。
好处：饿汉式是线程安全的

懒汉式：好处：延迟对象的创建。
目前的写法坏处：线程不安全。--->到多线程内容时，再修改


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

//懒汉式
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;
   }
   
}

main方法：

main()方法的使用说明：

main()方法作为程序的入口
main()方法也是一个普通的静态方法
main()方法可以作为我们与控制台交互的方式。（之前：使用Scanner）也就是它可以传入参数的，那个string[] args。在运行的时候，可以传入参数，编译的时候不可以穿参数。

代码块

代码块(或初始化块)的作用： 对Java类或对象进行初始化

由于类中不可以操作属性，不可以int a; a=10;这样子在语法上是过不去的，所以，出现了代码块，可以把这些操作放在代码块中。

代码块分为静态和非静态两种。

代码块(或初始化块)的分类：

一个类中代码块若有修饰符，则只能被static修饰，称为静态代码块 (static block)，

没有使用static修饰的，为非静态代码块。

静态代码块和非静态代码块的区别：

静态代码块

静态代码块的执行要先于非静态代码块。

静态代码块随着类的加载而加载，且只执行一次。

非静态代码块

若有多个非静态的代码块，那么按照从上到下的顺序依次执行。

每次创建对象的时候，都会执行一次。且先于构造器执行。

测试代码块和构造器的执行先后顺序

package 代码块;
//总结：由父及子，静态先行
class Root{
   static{
      System.out.println("Root的静态初始化块");
   }
   {
      System.out.println("Root的普通初始化块");
   }
   public Root(){
      super();
      System.out.println("Root的无参数的构造器");
   }
}
class Mid extends Root{
   static{
      System.out.println("Mid的静态初始化块");
   }
   {
      System.out.println("Mid的普通初始化块");
   }
   public Mid(){
      super();
      System.out.println("Mid的无参数的构造器");
   }
   public Mid(String msg){
      //通过this调用同一类中重载的构造器
      this();
      System.out.println("Mid的带参数构造器，其参数值："
         + msg);
   }
}
class Leaf extends Mid{
   static{
      System.out.println("Leaf的静态初始化块");
   }
   {
      System.out.println("Leaf的普通初始化块");
   }  
   public Leaf(){
      //通过super调用父类中有一个字符串参数的构造器
      super("尚硅谷");
      System.out.println("Leaf的构造器");
   }
}
public class LeafTest{
   public static void main(String[] args){
      new Leaf(); 
      System.out.println();
      new Leaf();
      
//    输出结果
      /**
       *由父及子 静态先行 显示静态代码块>非静态代码块>构造器>
       */
      /**
       * Root的静态初始化块
       * Mid的静态初始化块
       * Leaf的静态初始化块
       * Root的普通初始化块
       * Root的无参数的构造器
       * Mid的普通初始化块
       * Mid的无参数的构造器
       * Mid的带参数构造器，其参数值：尚硅谷
       * Leaf的普通初始化块
       * Leaf的构造器
       *
       * Root的普通初始化块
       * Disconnected from the target VM, address: '127.0.0.1:9046', transport: 'socket'
       * Root的无参数的构造器
       * Mid的普通初始化块
       * Mid的无参数的构造器
       * Mid的带参数构造器，其参数值：尚硅谷
       * Leaf的普通初始化块
       * Leaf的构造器
       */
   }
}

对属性可以赋值的位置：
①默认初始化
②显式初始化/⑤在代码块中赋值
③构造器中初始化
④有了对象以后，可以通过"对象.属性"或"对象.方法"的方式，进行赋值

final关键字

final:最终的

final可以用来修饰的结构：类、方法、变量
final 用来修饰一个类:此类不能被其他类所继承。
比如：String类、System类、StringBuffer类
final 用来修饰方法：表明此方法不可以被重写
比如：Object类中getClass();
final 用来修饰变量：此时的"变量"就称为是一个常量
4.1 final修饰属性：这个属性必须要初始化，也就是有默认值，而且是每一个构造器里都有这个默认值，防止个别构造器漏了给final修饰的属性的赋值。可以考虑赋值的位置有：显式初始化、代码块中初始化、构造器中初始化，不可以在方法中，必须是在构造器之前或者构造器中初始化。不可以在方法中。
4.2 final修饰局部变量：
尤其是使用final修饰形参时，表明此形参是一个常量。当我们调用此方法时，给常量形参赋一个实参。一旦赋值
以后，就只能在方法体内使用此形参，但不能进行重新赋值。

static final 用来修饰属性：全局常量

抽象类与抽象方法

抽象类是用来模型化那些父类无法确定全部实现，而是由其子类提供具体实现的对象的类。

个人理解：抽象类不一定有抽象方法，但是又抽象方法的类一定是抽象类。抽象类是介于接口和类之间的产物，接口只是限定方法，但是继承类可以实例化，而且也有属性和方法。但是抽象类不可以实例化，有属性，也可以有自己的方法。是抽出共同的部分，如果抽象类没有抽象方法，那么这个抽象类依然是有意义的，他代表了共同的属性，这个时候他和继承类有点像了，但是他不可以实例化。

1.abstract:抽象的
2.abstract可以用来修饰的结构：类、方法
3. abstract修饰类：抽象类
      > 此类不能实例化
     > 抽象类中一定有构造器，便于子类实例化时调用（涉及：子类对象实例化的全过程）
     > 开发中，都会提供抽象类的子类，让子类对象实例化，完成相关的操作
4. abstract修饰方法：抽象方法
	  > public abstract void talk();
      > 抽象方法只有方法的声明，没有方法体
      > 包含抽象方法的类，一定是一个抽象类。反之，抽象类中可以没有抽象方法的。
     > 若子类重写了父类中的所有的抽象方法后，此子类方可实例化
       若子类没有重写父类中的所有的抽象方法，则此子类也是一个抽象类，需要使用abstract修饰

abstract使用上的注意点
不能用abstract修饰变量、代码块、构造器；
不能用abstract修饰私有方法、静态方法、final的方法、final的类。

模板方法设计模式

接口

接口就是规范，定义的是一组规则，体现了现实世界中“如果你是/要...则必须能...”的思想。继承是一个"是不是"的关系，而接口实现则是 "能不能" 的关系。

接口的本质是契约，标准，规范，就像我们的法律一样。制定好后大家都要遵守。

接口(interface)是抽象方法和常量值定义的集合。

接口的特点：
用interface来定义。
接口中的所有成员变量都默认是由public static final修饰的。
接口中的所有抽象方法都默认是由public abstract修饰的。
接口中没有构造器。
接口采用多继承机制。

interface Flyable{
	//全局常量
	public static final int MAX_SPEED = 7900;//第一宇宙速度
	int MIN_SPEED = 1;//省略了public static final
	//抽象方法
	public abstract void fly();
	//省略了public abstract
	void stop();
	//Interfaces cannot have constructors
//	public Flyable(){
//		
//	}
}

接口的使用
1.接口使用interface来定义
2.Java中，接口和类是并列的两个结构
3.如何定义接口：定义接口中的成员
3.1 JDK7及以前：只能定义全局常量和抽象方法
>全局常量：public static final的.但是书写时，可以省略不写
>抽象方法：public abstract的
3.2 JDK8：除了定义全局常量和抽象方法之外，还可以定义静态方法、默认方法（略）

接口中不能定义构造器的！意味着接口不可以实例化
Java开发中，接口通过让类去实现(implements)的方式来使用.
如果实现类覆盖了接口中的所有抽象方法，则此实现类就可以实例化
如果实现类没有覆盖接口中所有的抽象方法，则此实现类仍为一个抽象类
Java类可以实现多个接口 --->弥补了Java单继承性的局限性，一般都是先继承，后面是实现
格式：class AA extends BB implements CC,DD,EE
接口与接口之间可以继承，而且可以多继承
接口的具体使用，体现多态性
接口，实际上可以看做是一种规范
面试题：抽象类与接口有哪些异同？

JAVA8中接口的新特性

Java 8中，你可以为接口添加静态方法和默认方法。从技术角度来说，这是完全合法的，只是它看起来违反了接口作为一个抽象定义的理念。

静态方法：使用 static 关键字修饰。可以通过接口直接调用静态方法，并执行其方法体。我们经常在相互一起使用的类中使用静态方法。你可以在标准库中找到像Collection/Collections或者Path/Paths这样成对的接口和类。

默认方法：默认方法使用 default 关键字修饰。可以通过实现类对象来调用。我们在已有的接口中提供新方法的同时，还保持了与旧版本代码的兼容性。比如：java 8 API中对Collection、List、Comparator等接口提供了丰富的默认方法。

 若一个接口中定义了一个默认方法，而另外一个接口中也定义了一个同名同参数的方法（不管此方法是否是默认方法），在实现类同时实现了这两个接口时，会出现：接口冲突。  解决办法：实现类必须覆盖接口中同名同参数的方法，来解决冲突。
若一个接口中定义了一个默认方法，而父类中也定义了一个同名同参数的非抽象方法，则不会出现冲突问题。因为此时遵守：类优先原则。接口中具有相同名称和参数的默认方法会被忽略。

s.method1();
SubClass.method1();
//知识点1：接口中定义的静态方法，只能通过接口来调用。
CompareA.method1();
//知识点2：通过实现类的对象，可以调用接口中的默认方法。
//如果实现类重写了接口中的默认方法，调用时，仍然调用的是重写以后的方法
s.method2();
//知识点3：如果子类(或实现类)继承的父类和实现的接口中声明了同名同参数的默认方法，口头表达父类中的方法和接口中的默认方法相同了，优先父类。
//那么子类在没有重写此方法的情况下，默认调用的是父类中的同名同参数的方法。-->类优先原则
//知识点4：如果实现类实现了多个接口，而这多个接口中定义了同名同参数的默认方法，
//那么在实现类没有重写此方法的情况下，报错。-->接口冲突。口头表达就是C类实现了A,B接口，A,B接口中都有共同的默认方法，这个时候就接口冲突了
//这就需要我们必须在实现类中重写此方法
//知识点5：如何在子类(或实现类)的方法中调用父类、接口中被重写的方法
	public void myMethod(){
		method3();//调用自己定义的重写的方法
		super.method3();//调用的是父类中声明的
		//调用接口中的默认方法
		CompareA.super.method3();
		CompareB.super.method3();
	}

代理模式：

代理类和被代理类同时实现一个接口，接口中的方法重写是在代理类中，被代理类拿到了被代理类的重写方法之后，可以在他之前或者之后做一些事情。

代码如下：

package 接口的应用;
/*
 * 接口的应用：代理模式
 * 
 */
public class NetWorkTest {
	public static void main(String[] args) {
		Server server = new Server();
//		server.browse();
		ProxyServer proxyServer = new ProxyServer(server);
		
		proxyServer.browse();
		
	}
}

interface NetWork{
	
	public void browse();
	
}

//被代理类
class Server implements NetWork{

	@Override
	public void browse() {
		System.out.println("真实的服务器访问网络");
	}

}
//代理类
class ProxyServer implements NetWork{
	
	private NetWork work;
	
	public ProxyServer(NetWork work){
		this.work = work;
	}
	

	public void check(){
		System.out.println("联网之前的检查工作");
	}
	
	@Override
	public void browse() {
		check();
		work.browse();	
	}	
}

代理模式的应用场景：
安全代理：屏蔽对真实角色的直接访问。
远程代理：通过代理类处理远程方法调用（RMI）
延迟加载：先加载轻量级的代理对象，真正需要再加载真实对象比如你要开发一个大文档查看软件，大文档中有大的图片，有可能一个图片有100MB，在打开文件时，不可能将所有的图片都显示出来，这样就可以使用代理模式，当需要查看图片时，用proxy来进行大图片的打开。
分类
静态代理（静态定义代理类）
动态代理（动态生成代理类）
JDK自带的动态代理，需要反射等知识

类的内部成员之五：内部类

Java中允许将一个类A声明在另一个类B中，则类A就是内部类，类B称为外部类
内部类的分类：成员内部类（静态、非静态） vs 局部内部类(方法内、代码块内、构造器内)
成员内部类：
一方面，作为外部类的成员：
调用外部类的结构
可以被static修饰
可以被4种不同的权限修饰

另一方面，作为一个类：

类内可以定义属性、方法、构造器等
可以被final修饰，表示此类不能被继承。言外之意，不使用final，就可以被继承
可以被abstract修饰
关注如下的3个问题
1. 如何实例化成员内部类的对象
2. 如何在成员内部类中区分调用外部类的结构
3. 开发中局部内部类的使用见《InnerClassTest1.java》

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);//外部类的属性
      }
   }
   
   
   public void method(){
      //局部内部类
      class AA{
      }
   }
   
   {
      //局部内部类
      class BB{
      }
   }
   
   public Person(){
      //局部内部类
      class CC{
      }
   }
}

局部内部类的使用场景：给方法的返回值一个具体的实现，并且返回。

在局部内部类的方法中（比如：show）如果调用局部内部类所声明的方法(比如：method)中的局部变量(比如：num)的话,
要求此局部变量声明为final的。
jdk 7及之前版本：要求此局部变量显式的声明为final的
jdk 8及之后的版本：可以省略final的声明,但是不可以修改变量的值。
	public void method(){
		//局部变量
		int num = 10;
		class AA{
			public void show(){
			num = 20;//不可以这样，直接报错了。实际上还是final的。
				System.out.println(num);
			}
		}
	}

    //返回一个实现了Comparable接口的类的对象
   public Comparable getComparable(){
      
      //创建一个实现了Comparable接口的类:局部内部类
      //方式一：
//    class MyComparable implements Comparable{
//
//       @Override
//       public int compareTo(Object o) {
//          return 0;
//       }
//       
//    }
//    
//    return new MyComparable();
      
      //方式二：
      return new Comparable(){

         @Override
         public int compareTo(Object o) {
            return 0;
         }
         
      };
      
   }

posted @ 2023-02-19 21:24 孙立人bc 阅读(22) 评论(0) 收藏举报

刷新页面返回顶部