13.继承、重载、重写、多态、抽象类、接口、final、Static的学习

一、继承

继承：你继承谁你就是谁，继承是一种严格的父子关系 （在父类里面抽取的属性和方法一定是所有子类所共有）

（Student继承Person，那么Student就是人）

UML: 类图（描述类和类之间的关系）

UML所用箭头的含义：

uml图六种箭头的含义（泛化、实现、依赖、关联、聚合、组合）-CSDN博客

Java是单继承，就是一个类只能继承extends(inherit)一个类，而java这种面向对象的语言就是对现实世界的描述，现实世界中是存在很多多继承，但是java里面是支持实现多个接口。

Object是所有类的父类（这个父类不一定是直接父类）

//一个类不继承任何一个类，默认继承Object
public class Person/* extends Object*/{//如果希望子类继承 protectedprotected int id;protected String name;protected int age;public Person() {//Java里面new子类对象时候首先new父类对象super();//new Object();}public Person(int id, String name, int age) {super();this.id = id;this.name = name;this.age = age;}public void show() {System.out.println("Person.show");}
}//实体类：和数据库表一一对应
public class Student extends Person{
//    private int id;
//    private String name;
//    private int age;private String className;public Student() {super();//new Person();}public Student(int id, String name, int age, String className) {super(id, name, age);//new Person(id,name,age)this.className = className;}//    public void show() {
//        System.out.println("Student.show");
//    }public void study() {System.out.println(className + "班的"+name+"正在学习");}
}

private:只在当前类里面可以访问（子类也不能访问）

public：任何地方都可以访问

protected：子类可以访问

import：

Java里面用到类需要import进来，本包的类不需要import，外部包需要import

特例：java.lang包放很多Java常用类像System、String，这个包下面是不需要导包

不写，java默认加上：

1、无参构造方法

2、一个类不继承任何一个类默认继承extends Object

3、在类的构造方法第一句默认会加上super()

this、super总结：

1. this:代表当前类的对象 this.id=id
2. super：代表父类对象
3. this():调用当前类的构造方法
4. super():调用父类构造方法

public class Rectangle {private int width;private int height;public Rectangle() {this(1, 1);//new Rectangle(1, 1)
//        this.width = 1;
//        this.height = 1;}public Rectangle(int width, int height) {this.width = width;this.height = height;}
}

二、重载

重载（Overload）是指在同一个类中可以有多个方法拥有相同的名称，但是它们的参数列表不同。

Java通过方法的 参数类型、个数或顺序 来区分不同的重载方法。

最典型的重载：构造方法重载（无参构造方法、有参构造方法）

方法重载特点： 与返回值无关，只看参数列表。

void show(int a, char b, double c){}

1、void show(int x, char y, double z){} 不是重载，是同一个方法

2、int show(int a, double c, char b){} 是重载，参数顺序不一样，和返回值无关

3、void show(int a, double c, char b){} 是重载，参数顺序不一样

4、boolean show(int c, char b){} 是重载

5、void show(double c){ } 是重载

6、double show(int x, char y, double z){} 不是重载

三、重写

重写（覆盖）@Override

父类中定义的方法子类不满意，子类重新定义这个方法，最典型的重写就是toString()

1、子类覆盖父类，必须保证子类权限大于父类权限才可以覆盖，否则会编译失败。

2、如果父类是private的方法，子类是默认方法，那么子类是不知道这个方法的，不是覆盖。

public class Object {public String toString() {return getClass().getName() + "@" + Integer.toHexString(hashCode());}
}public class Student {@Overridepublic String toString() {return "Student{" +"className='" + className + '\'' +", id=" + id +", name='" + name + '\'' +", age=" + age +'}';}
}

重载（Overload）： 同一个类中 方法名一样参数列表不一样（构造方法重载）

重写（Override）： 父子类 中方法（父类中定义的方法子类不满意，子类重新定义这个方法）

四、多态

Java 多态（Polymorphism）是面向对象编程的一项核心概念，它允许对象以多种形式出现。

多态性在Java中有两个主要的表现形式：

1. 编译时多态（也称为静态多态）
2. 运行时多态（也称为动态多态）

编译时多态是通过方法重载（Method Overloading）实现的。这意味着在同一个类中可以定义多个方法，这些方法具有相同的名字但参数列表不同。编译器在编译时根据参数列表来决定调用哪个具体的方法。

这里大家只要知道多态还有编译时多态这种形式就可以，重点还是运行时多态。

多态存在的三个必要条件：

1. 继承
2. 重写
3. 父类引用指向子类对象 Cal cal = new Add();

面向接口编程：声明成父类类型，那么所有的子类对象都可以传递过来

//Cal cal = new Add();
public void jiSuan(Cal cal) {cal.getResult();
}public void jiSuan(Add add) {add.getResult();
}public void jiSuan(Sub sub) {sub.getResult();
}public void jiSuan(Mul mul) {mul.getResult();
}

五、抽象类、抽象方法

1、抽象方法是没有方法体，如果这个类里面有抽象方法，这个类必须变成抽象类。

2、如果这个类是抽象类，并不要求这个类一定要有抽象方法

3、抽象类里面可以有普通方法，也可以有抽象方法。

4、如果一个类是抽象类，那么这个类就不能被new实例化，只能被其他类继承。

5、抽象方法可以理解为父类（抽象类） 定义的一个模板或者规范（自己本身不实现），子类必须实现这个抽象方法 ，如果子类不想实现这个方法，那么这个子类也必须要变成抽象类。

public abstract class Cal {protected int num1;protected int num2;//抽象方法是没有方法体，如果这个类里面有抽象方法，这个类必须变成抽象类。public abstract int getResult();//方法签名/*public int getResult() {//大括号：方法体//为了不让他报错return 0;}*/}

六、接口interface

接口是一个纯粹的抽象类（接口里面所有的方法都是抽象方法）

接口就是一个规范(标准)，他没有提供任何是实现，具体的功能由实现接口的子类去实现。

接口就是一个规范， 可插拔（可以被替换，首先定义一个标准（接口），大家都遵守这个标准，就可以实现互相之间替换）

白炽灯的接口

计算机主板上CPU、内存

面向接口编程这个接口有广义和狭义：

狭义：就是Java里面接口这个技术

广义：声明成父类类型，指向不同的子类对象。这里的父类可以是：接口、抽象类、普通父类

接口也是父类的一种

//接口就是一个纯粹的抽象类，接口就是一个标准
public interface IFly {//public static final double PI = 3.14;double PI = 3.14;//public abstract void fly();void fly();}

如何选择接口还是抽象类

1. 继承是严格的父子关系，你继承什么你就是什么：鸽子就是鸟。

父类是抽取了所有子类的 共同特征，父类里面的属性和方法是所有子类所共有的属性和方法。

1. 接口是一个标准，一般用在能不能具有某个功能。

把能不能飞定义称为一个接口IFly， 实现了这个接口的类就具有了这个功能。

public void test1() {DaYan daYan = new DaYan();daYan.egg();daYan.fly();daYan.print();// bird是站在AbstractBird这个类角度去看new出来的DaYan这个对象，// 所以只能看到egg()这个方法AbstractBird bird = new DaYan();bird.egg();// bird.fly();// bird.show();// 站在能不能飞IFly的角度去看DaYan，只能看到fly()这个方法IFly fly = new DaYan();fly.fly();//fly.egg();//fly.show();fly = new GeZi();fly.fly();
}public void flay(IFly fly) {fly.fly();
}

接口的特点：

1、接口是一个纯粹的抽象类，接口里面的方法都是抽象方法：public abstract

2、接口里面所有的属性：public static final double PI = 3.14;

final总结：修饰变量、类、方法

final:最终的意思

1. final变量：这个变量就不能被修改,就是常量 public static final double PI = 3.1415;
2. final类：这个类就不能被继承
3. final方法：这个方法就不能被重写

七、静态属性、静态方法

如何理解静态属性、静态方法

小区里面业主的房子可以看成一个一个的对象，这些都是属于特定的业主所独有。但是小区里面也有一些公共设施（健身器材、绿地），这些公共设施是属于这个小区的。但是是可以被所有的业主对象所使用的。

非静态的属性和方法（实例属性和方法）必须通过new对象访问，而静态的属性和方法是属于类的，在类加载到内存中就可以访问，不需要new对象就可以使用，但是可以被所有对象所共享。

使用时候注意点：

1、静态的方法只能访问静态的方法和静态的属性（因为当前对象的实例可以没有创建，所以静态的方法是没办法调用非静态的方法和属性的）

2、静态的方法中不能写this、super关键字(因为当前的对象实例可能还没有创建，代表当前类对象的this还有代表父类对象的super可能都还没有创建)

public class Student {//属性、成员变量、实例变量public int id;private String name;//静态变量public static String country = "中国";//成员方法、实例方法、非静态方法public void show() {System.out.println("Student.show");print();}//静态方法public static void print() {System.out.println("Student.print");//Non-static method 'show()' cannot be referenced from a static context//show();//this.name = "lisi";country = "zhongguo";//this.name = "ss";}public static void test() {test();}public int getId() {return id;}public void setId(int id) {this.id = id;}public String getName() {return name;}public void setName(String name) {this.name = name;}
}

八、工具类

Math、Arrays

1. 工具类里面的方法都是静态方法，方法之间没有关联。
2. 工具类的构造方法私有，禁止外界new对象，只能通过类名.方法方式访问

//工具类
int max1 = Math.max(3, 2);
System.out.println(max1);
double max2 = Math.max(3.0, 5.2);
System.out.println(max2);
//'Math()' has private access in 'java.lang.Math'
//Math math = new Math();//Arrays数组操作的工具类
int[] array = {34, 45, 7, 89};
System.out.println(array);//[I@d7b1517
System.out.println(Arrays.toString(array));
Arrays.sort(array);
System.out.println(Arrays.toString(array));
//先Arrays.sort排好序，再进行二分查找
int index = Arrays.binarySearch(array, 7);
System.out.println(index);public class ArraysUtil {private ArraysUtil() {}public static int sum(int[] array) {int sum = 0;for (int i : array) {sum += i;}return sum;}public static int max(int[] array) {int max = array[0];for (int i : array) {if (i > max) {max = i;}}return max;}public static void bubbleSort(int[] array) {}
}