final关键字的用法：
1. final关键字修饰一个基本类型的变量时，该变量不能重新赋值，第一次的值为最终的。
2. fianl关键字修饰一个引用类型变量时，该变量不能重新指向新的对象。
3. final关键字修饰一个函数的时候，该函数不能被重写。
4. final关键字修饰一个类的时候，该类不能被继承。
常量 的修饰符一般为： public static final
二、抽象类：
目前存在的问题：
1. 动物类的run方法描述的不正确。
2. 没有强制要子类一定要重写run方法。
抽象类的应用场景：
我们在描述一类事物的时候，发现该种事物确实存在着某种行为，
但是这种行为目前是不具体的，那么我们可以抽取这种行为 的声明，但是
不去实现该种行为，这时候这种行为我们称作为抽象的行为，我们就需要使用抽象类。
抽象类的好处: 强制要求子类一定要实现指定的方法。
抽象类要注意的细节：
1. 如果一个函数没有方法体，那么该函数必须要使用abstract修饰,把该函数修饰成抽象 的函数。。
2. 如果一个类出现了抽象的函数，那么该类也必须 使用abstract修饰。
3. 如果一个非抽象类继承了抽象类，那么必须要把抽象类的所有抽象方法全部实现。
4. 抽象类可以存在非抽象方法，也可以存在抽象的方法.
5. 抽象类可以不存在抽象方法的。
5. 抽象类是不能创建对象的。
疑问：为什么抽象类不能创建对象呢？
因为抽象类是存在抽象方法的，如果能让抽象类创建对象的话，那么使用抽象的对象
调用抽象方法是没有任何意义的。
6. 抽象类是存在构造函数的，其构造函数是提供给子类创建对象的时候初始化父类的属性的。
常量的命名规范：全部字母大写，单词与单词 之间 使用下划线分隔。
abstract不能与以下关键字共同修饰一个方法：
1. abstract 不能与private共同修饰一个方法。
2. abstract 不能与static共同修饰一个方法。
3. abstract 不能与final共同修饰一个方法。
三、值传递
值传递: 调用一个方法的时候，传递给方法的参数 ，实际上传递变量所存储的值。
import java.util.*;
class Person{
int x =10;
}
class Demo5
{
public static void main(String[] args)
{
/*
int a = 3;
int b = 5;
changeValue(a,b);
System.out.println("交换之后的值：a = "+a +" b="+b);
int[] arr = {23,10,9};
changeArr(arr,1,2);
System.out.println("数的元素："+ Arrays.toString(arr));// 9 ,10
*/
Person p = new Person();
changeObj(p,20);
System.out.println("x = "+ p.x);
}
public static void changeObj(Person p ,int x){
p.x = x;
}
//需求2： 定义一个函数交换数组中两个 元素的位置。
public static void changeArr(int[] arr , int index1, int index2){
int temp = arr[index1];
arr[index1] = arr[index2];
arr[index2] = temp;
}
//需求1：定义一个函数交换两个基本类型变量的值。
public static void changeValue(int a , int b){
int temp = a;
a = b;
b = temp;
System.out.println("方法内部交换的值：a = "+a +" b="+b);
}
}
四、接口
一个类最多只能有一个直接的父类。但是有多个间接的父类。java是单继承。
接口：拓展功能的。 usb接口.。。
接口的定义格式：
interface 接口名{
}
接口要注意的事项 ：
1. 接口是一个特殊的类。
2. 接口的成员变量默认的修饰符为： public static final 。那么也就是说接口中的成员变量都是常量。
3. 接口中 的方法都是抽象的方法，默认的修饰符为： public abstract。
4. 接口不能创建对象。
5. 接口是没有构造方法的。
6. 接口是给类去实现使用的，非抽象类实现一个接口的时候，必须要把接口中所有方法全部实现。
实现接口的格式：
class 类名 implements 接口名{
}
interface （定义接口）
implements (实现接口)
接口的作用：
1. 程序的解耦。 （低耦合）
2. 定义约束规范。
3. 拓展功能。
class Student{
String name;
public Student(String name){
this.name = name;
}
public void study(){
System.out.println(name+"好好学习");
}
}
//挣钱是学生拓展的功能---定义在接口上
interface Money{
public void makeMoney();
}
//会挣钱的学生
class MoneyStudent extends Student implements Money{
public MoneyStudent(String name){
super(name);
}
public void makeMoney(){
System.out.println(name+"好好挣钱，然后交学费！");
}
}
class Demo9
{
public static void main(String[] args)
{
Student s = new Student("李金华");
s.study();
//s.makeMoney();
MoneyStudent m = new MoneyStudent("孙双双");
m.study();
m.makeMoney();
}类与接口要注意的事项：
1. 非抽象类实现一个接口时，必须要把接口中所有方法全部实现。
2. 抽象类实现一个接口时，可以实现也可以不实现接口中的 方法。
3. 一个类可以实现多个接口 。
接口与接口之间关系： 继承关系。
接口与接口之间要注意事项：
1. 一个接口是可以继承多个接口的。
五、多态
一个对象具备多种形态。(父类的引用类型变量指向了子类的对象)
或者是接口 的引用类型变量指向了接口实现类的对象)
多态的前提：必须存在继承或者实现 关系。
动物 a = new 狗();
多态要注意 的细节：
1. 多态情况下，子父类存在同名的成员变量时，访问的是父类的成员变量。
2. 多态情况下，子父类存在同名的非静态的成员函数时，访问的是子类的成员函数。
3. 多态情况下，子父类存在同名的静态的成员函数时，访问的是父类的成员函数。
4. 多态情况下，不能访问子类特有的成员。
总结：多态情况下，子父类存在同名的成员时，访问的都是父类的成员，除了在同名非静态函数时才是访问子类的。
编译看左边，运行不一定看右边。
编译看左边：java编译器在编译的时候，会检查引用类型变量所属的类是否具备指定的成员，如果不具备马上编译报错。
abstract class MyShape{
public abstract void getArea();
public abstract void getLength();
}
class Circle extends MyShape{
public static final double PI = 3.14;
double r;
public Circle(double r){
this.r =r ;
}
public void getArea(){
System.out.println("圆形的面积："+ PI*r*r);
}
public void getLength(){
System.out.println("圆形的周长："+ 2*PI*r);
}
}
class Rect extends MyShape{
int width;
int height;
public Rect(int width , int height){
this.width = width;
this.height = height;
}
public void getArea(){
System.out.println("矩形的面积："+ width*height);
}
public void getLength(){
System.out.println("矩形的周长："+ 2*(width+height));
}
}
class Demo12 {
public static void main(String[] args)
{
/*
//System.out.println("Hello World!");
Circle c = new Circle(4.0);
print(c);
Rect r = new Rect(3,4);
print(r);
*/
MyShape m = getShape(0); //调用了使用多态的方法，定义的变量类型要与返回值类型一致。
m.getArea();
m.getLength();
}
//需求1： 定义一个函数可以接收任意类型的图形对象，并且打印图形面积与周长。
public static void print(MyShape s){ // MyShpe s = new Circle(4.0);
s.getArea();
s.getLength();
}
// 需求2： 定义一个函数可以返回任意类型的图形对象。
public static MyShape getShape(int i){
if (i==0){
return new Circle(4.0);
}else{
return new Rect(3,4);
}
}
}多态的应用：
1. 多态用于形参类型的时候，可以接收更多类型的数据 。
2. 多态用于返回值类型的时候，可以返回更多类型的数据。
多态的好处： 提高了代码的拓展性。