07-面向对象高级（面向对象）

感谢你的路过，希望学生的笔记能给你一点微不足道的参考（1/100）
Java面向对象思维导图，[完整Java体系的链接]

一，继承格式

1.1继承的由来？

   多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要 继承那一个类即可。多个类可以称为子类，单独那一个类称为父类、超类（superclass）或者基类。通过继承，可以使多种事物之间形成一种关系体系

1.2继承是怎么定义的？

    继承就是子类继承父类的属性和行为，使得子类对象具有与父类相同的属性、相同的行为。子类可以直接 访问父类中的非私有的属性和行为。

1.3继承的好处有哪些？

   1. 提高代码的复用性
   2. 类与类之间产生了关系，是多态的前提

1.4继承的格式是怎样的？

   通过 extends 关键字，可以声明一个子类继承另外一个父类，定义格式如下：
      class 父类 {
       …
       }
      class 子类 extends 父类 {
      …
      }

1.5继承的限制？

   Java中只有单继承，多重继承，没有多继承。

   进行继承的内存分析时记住：
      创建子类对象前会先查看有无父类对象，有则先创建父类对象。在创建子类对象。
      子类对象中没有的属性或方法，会去父类中寻找。子类中的super()默认存储父类对象地址。
   例子：

1.6super关键字？

    通过super关键字，可以访问父类构造方法，属性，方法。调用super构造方法的代码，必须写在子类构造方法的第一行。
代码：

package JiCheng;

/**
 * @Description: TODO(父类) 
 * super:
 * 	1. 在子类的成员方法中，访问父类的成员变量。
	2. 在子类的成员方法中，访问父类的成员方法。
	3. 在子类的构造方法中，访问父类的构造方法。
		调用super构造方法的代码，必须写在子类构造方法的第一行。
 * @author: 王宇辉
 * @Date: 2021年8月17日 上午9:29:18
 */
public class Person {
   
	
	private String name;
	private int age;
	public String sex;
	
	public String getName() {
   
		return name;
	}

	public void setName(String name) {
   
		this.name = name;
	}

	public int getAge() {
   
		return age;
	}

	public void setAge(int age) {
   
		this.age = age;
	}

	public Person() {
   
		
	}
	
	public Person(String name,int age) {
   
		this.name=name;
		this.age=age;
	}	
	
	public void say() {
   
        System.out.println("姓名："+name+"，年龄:"+age+"，性别:"+sex);
    }
	
	public void method() {
   
        System.out.println("方法执行！");
    }
}

package JiCheng;

/**
 * @Description: TODO(子类) 
 * @author: 王宇辉
 * @Date: 2021年8月17日 上午9:30:28
 */
public class Assistant extends Person{
   

}

package JiCheng;
/**
 * @Description: TODO(子类及super关键字) 
 * @author: 王宇辉
 * @Date: 2021年8月17日 上午9:30:28
 */
public class Student extends Person{
   

	public Student() {
   
		super("无名",30);
		super.sex="男";
		super.method();
	}
}

package JiCheng;

public class Demo01_JiChengGeShi {
   
	/**
	 * 继承：是Java面向对象技术的基石，因为允许创建分等级层次的类。
	 * 继承就是子类继承父类的属性和行为，使得子类对象具有与父类相同的属性、相同的行为。
	 * 子类可以直接 访问父类中的非私有的属性和行为。
	 * 格式：
	 * 	class 父类 { 
		... 
		}
		class 子类 extends 父类 { 
		...
		}
	 * @param args
	 */
	 public static void main(String[] args) {
   
	        // 创建了一个子类对象
	        Student s1 = new Student();
	        // s1.setName("王宇辉");
	        // s1.setAge(21);
	        // Teacher类会继承来自父类的method方法。
	        s1.say();

	        // 创建另一个子类的对象
	        Assistant assistant = new Assistant();
	        assistant.method();
	    }
}

二，重写与final？

2.1重写(Override) 规则:

    1、参数列表必须完全与被重写方法的相同，
    2、返回类型必须完全与被重写方法的返回类型相同;
    3、访问权限不能比父类中被重写的方法的访问权限更低。
        例如，如果父类的一个方法被声明为Pub1ic，那么在子类中重写该方法就不能声明为protected。
    4、父类的成员方法只能被它的子类重写。
    5、声明为static 和priVvete 的方法不能被重写，但是能够被再次声明。

2.2方法的覆盖重写特点：

    创建的是子类对象，则优先用子类方法.

2.3Java 中重写(Override) 与重载(Over1oad) 的区别

    1 、发生的位置
        重载，一个类中
        重写: 子父类中
    2、参数列表限制
        重载: 必须不同的
        重写: 必须相同的
    3、返回值类型
        重载: 与返回值类型无关
        重写: 返回值类型必须一致
    4、访问权限:
        重载: 与访问权限无关
        重写: 子的方法权限必须不能小于必父的方法权限
    5、异常处理;
        重载: 于异常无关
        重写，异常范围可以更小，但是不能抛出新的异常。
代码：

package ZhongXie;
/**
*重写(Override) 规则:
1、参数列表必须完全与被重写方法的相同， 
2、返回类型必须完全与被重写方法的返回类型相同;
3、访问权限不能比父类中被重写的方法的访问权限更低。
	例如，如果父类的一个方法被声明为Pub1ic，那么在子类中重写该方法就不能声明为protected。
4、父类的成员方法只能被它的子类重写。
5、声明为static 和priVvete 的方法不能被重写，但是能够被再次声明。

方法的覆盖重写特点：
	创建的是子类对象，则优先用子类方法.

Java 中重写(Override) 与重载(Over1oad) 的区别
1 、发生的位置
	重载，一个类中	
	重写: 子父类中
2、参数列表限制
	重载: 必须不同的
	重写: 必须相同的
3、返回值类型
	重载: 与返回值类型无关 
	重写: 返回值类型必须一致
4、访问权限:
	重载: 与访问权限无关
	重写: 子的方法权限必须不能小于必父的方法权限
5、异常处理;
	重载: 于异常无关 
	重写，异常范围可以更小，但是不能抛出新的异常。

 * @author: 王宇辉
 * @Date: 2021年8月17日 上午10:36:00
 */
public class Demo02_Override {
   
	
	public static void main(String[] args) {
   
      Student01 student = new Student01();
      student.say();
    }
}

class Person01{
   
	public void say() {
   
		System.out.println("111111111111111111");
	}
}

class Student01 extends Person01{
   
	public void say() {
   
		System.out.println("22222222222222222");
	}
}

2.4final关键字能干什么？

    用于修饰不可改变内容。
    final：
        类：被修饰的类，不能被继承
        方法：被修饰的方法，不能被重写
        变量：被修饰的变量，不能被重新赋值

2.5final关键字的使用方式？

    如何修饰类？
        格式如下：
            final class 类名 {
            }
    如何修饰方法？
        格式如下：
            修饰符 final 返回值类型 方法名(参数列表){
            //方法体
            }
        重写被 final 修饰的方法，编译时就会报错。
        注意事项：
            对于类、方法来说，abstract关键字和final关键字不能同时使用，因为矛盾。
    如何修饰变量？
        局部变量——基本类型
           基本类型的局部变量，被final修饰后，只能赋值一次，不能再更改。
        局部变量——引用类型
           引用类型的局部变量，被final修饰后，只能指向一个对象，地址不能再更改。但是不影响对象内部的成员变量值的修改。
        成员变量
           成员变量涉及到初始化的问题，初始化方式有两种，只能二选一：
           显示初始化
               被final修饰的常量名称，一般都有书写规范，所有字母都大写。
        构造方法初始化
       其他：
           1. 由于成员变量具有默认值，所以用了final之后必须手动赋值，不会再给默认值了。
           2. 对于final的成员变量，要么使用直接赋值，要么通过构造方法赋值。二者选其一。
           3. 必须保证类当中所有重载的构造方法，都最终会对final的成员变量进行赋值。
代码：

package Final;
/*
final关键字代表最终、不可改变的。

常见四种用法：
1. 可以用来修饰一个类
2. 可以用来修饰一个方法
3. 还可以用来修饰一个局部变量
4. 还可以用来修饰一个成员变量
 */
public class Demo03_Final {
   
	/**
	 * TODO final代码先放这里（不甚了解，目前影响不大。等之后在看看）
	 * final关键字
		final 用于修饰属性、变量-
		变量成为了常量，无法对其再次进行赋值。
		final 修饰的局部变量，只能赋值一次(可以先声明后赋值) 和final 修饰的是成员属性，必须在声明时赋值。 
		全局常量( public static final )

		常量的命名规范:
		由工个或多个单词组成，单词与单词之间必须使用下划线隔开，单词中所有字母大写    例如: SQL_INSERT

		final 用于修饰类
		final]修饰的类，不可以被继承。 final 用于修饰方法
		final 修饰的方法，不能被子类重写。

	 * 	Demo03_Final-（final关键字）
		MySubClass.java-（子类）
		Person.java-（修饰成员变量）
		Student.java-（修饰局部变量）
		Zi.java-（方法子类）
		Demo01Final.java-（对象）
		Fu.java-（修饰方法）
		MyClass.java-（修饰类）
	 * @param args
	 */
	 public static void main(String[] args) {
   
	        int num1 = 10;
	        System.out.println(num1); // 10
	        num1 = 20;
	        System.out.println(num1); // 20

	        // 一旦使用final用来修饰局部变量，那么这个变量就不能进行更改。
	        // “一次赋值，终生不变”
	        final int num2 = 200;
	        System.out.println(num2); // 200

//	        num2 = 250; // 错误写法！不能改变！
//	        num2 = 200; // 错误写法！

	        // 正确写法！只要保证有唯一一次赋值即可
	        final int num3;
	        num3 = 30;

	        // 对于基本类型来说，不可变说的是变量当中的数据不可改变
	        // 对于引用类型来说，不可变说的是变量当中的地址值不可改变
	        Student stu1 = new Student("赵丽颖");
	        System.out.println(stu1);
	        System.out.println(stu1.getName()); // 赵丽颖
	        stu1 = new Student("霍建华");
	        System.out.println(stu1);
	        System.out.println(stu1.getName()); // 霍建华
	        System.out.println("===============");

	        final Student s