面向对象编程

• 封装
• 继承
• 多态

继承

多个类可以称为子类，单独那一个类称为父类、超类（superclass）或者基类

继承：就是子类继承父类的属性和行为，使得子类对象具有与父类相同的属性、相同的行为。子类可以直接访问父类中的非私有的属性和行为。
好处
-提高代码的复用性。

• 类与类之间产生了关系，是多态的前提。
  使用 extends关键字进行继承
  父类

public class Employee {String name;public void work(){System.out.println("快乐的工作着");}
}

子类

public class Teacher extends Employee{public void printName(){System.out.println("name = " + name);}
}

测试

public class Test {public static void main(String[] args) {Teacher teacher = new Teacher();teacher.name = "小明";teacher.printName();teacher.work();}
}

继承后的特点-- 成员变量

• 成员变量不重名
  如果子类父类中出现不重名的成员变量，这时的访问是没有影响的。

public class Fu {int num = 5;
}
public class ZI extends Fu{int num2 = 6;public void show(){System.out.println("num = " +  num);System.out.println("num2 = " +  num2);}
}
public class Test {public static void main(String[] args) {ZI zi = new ZI();zi.show();}
}

• 成员变量重名
  子父类中出现了同名的成员变量时, 在子类中调用的时候调用的是子类的(就近)
  子父类中出现了同名的成员变量时，在子类中需要访问父类中非私有成员变量时，需要使用 super 修饰父类成员变量, 本类可以使用this

public class Fu {int num = 5;
}
public class ZI extends Fu {int num = 6;public void show(){System.out.println("Fu = " +  super.num);System.out.println("zi = " +  this.num);}
}
public class Test {public static void main(String[] args) {ZI zi = new ZI();zi.show();}
}

小贴士：Fu类中的成员变量是非私有的，子类中可以直接访问。若Fu
类中的成员变量私有了，子类是不能直接访问的。通常编码时，我们遵循封装的原则，使用private修饰成员变量，那么如何访问父类的私有成员变量呢？对！可以在父类中提供公共的getXxx方法和setXxx方法。

继承后的特点——成员方法

• 成员方法不重名
  如果子类父类中出现不重名的成员方法，这时的调用是没有影响的。对象调用方法时，会先在子类中查找有没有对应的方法，若子类中存在就会执行子类中的方法,
  若子类中不存在就会执行父类中相应的方法。

public class Fu {public void  show(){System.out.println("Fu  show()");}
}public class ZI extends Fu {public void  show2(){System.out.println("Zi  show2()");}
}
public class Test {public static void main(String[] args) {ZI zi = new ZI();zi.show2();zi.show();}
}

• 成员方法重名
  如果子类父类中出现重名的成员方法，这时的访问是一种特殊情况，叫做方法重写(Override)。

方法重写

子类中出现与父类一模一样的方法时（返回值类型，方法名和参数列表都相同），会出现覆盖效果，也称为重写或者复写。声明不变，重新实现

public class Fu {public void  show(){System.out.println("Fu  show()");}
}
public class ZI extends Fu {public void  show(){System.out.println("Zi  show()");}
}

重写的应用

public class Phone {public void sendMessage() {System.out.println("发短信");}public void call() {System.out.println("打电话");}public void showNum() {System.out.println("来电显示号码");}
}
package com.claire.day07.demo5;public class NewPhone extends Phone{@Overridepublic void showNum() {// 调用父类的同名方法super.showNum();System.out.println("显示来电的头像");}
}
public class Test {public static void main(String[] args) {NewPhone newPhone = new NewPhone();newPhone.showNum();}
}

注意:

• 子类方法覆盖父类方法，必须要保证权限大于等于父类权限。
• 子类方法覆盖父类方法，返回值类型、函数名和参数列表都要一模一样

继承后的特点——构造方法

首先我们要回忆两个事情，构造方法的定义格式和作用。

1. 构造方法的名字是与类名一致的。所以子类是无法继承父类构造方法的。
2. 构造方法的作用是初始化成员变量的。所以子类的初始化过程中，必须先执行父类的初始化动作。子类的构造方法中默认有一个super()
   表示调用父类的构造方法，父类成员变量初始化后，才可以给子类使用

public class Fu {private int n;Fu(){System.out.println("Fu 构造");}
}
public class ZI extends Fu {ZI(){super(); // 先调用父类的构造方法 这里不写也会调用System.out.println("ZI() 构造");}
}
public class Test {public static void main(String[] args) {new ZI();}
}

父类空间优先于子类对象产生
在每次创建子类对象时，先初始化父类空间，再创建其子类对象本身。目的在于子类对象中包含了其对应的父类空
间，便可以包含其父类的成员，如果父类成员非private修饰，则子类可以随意使用父类成员。代码体现在子类的构造方法调用时，一定先调用父类的构造方法

super和this的含义

• super：代表父类的存储空间标识(可以理解为父亲的引用)。
• this：代表当前对象的引用(谁调用就代表谁)。

super和this的用法

1.访问成员

this.成员变量  本类的
super.成员变量  父类的
this.成员方法名()  本类的
super.成员方法名()  父类的

2. 访问构造方法

this(...)  本类的构造方法
super(...)  父类的构造方法

• 子类的每个构造方法中均有默认的super()，调用父类的空参构造。手动调用父类构造会覆盖默认的super()。
• super()和 this() 都必须是在构造方法的第一行，所以不能同时出现。

继承的特点

1. Java只支持单继承，不支持多继承。 子类继承父类
   
2. Java支持多层继承(继承体系)。
   3.

顶层父类是Object类。所有的类默认继承Object，作为父类。

• 子类和父类是一种相对的概念。

public boolean equals(Object obj) {return (this == obj);}

public boolean equals(Object anObject) {if (this == anObject) {return true;}// instanceof  String 是否属于String类型if (anObject instanceof String) {// 强制转换为 String类型String anotherString = (String)anObject;int n = value.length;if (n == anotherString.value.length) {char v1[] = value;char v2[] = anotherString.value;int i = 0;while (n-- != 0) {if (v1[i] != v2[i])return false;i++;}return true;}}return false;}

public String toString() {return getClass().getName() + "@" + Integer.toHexString(hashCode());}

抽象类

父类中的方法，被它的子类们重写，子类各自的实现都不尽相同。那么父类的方法声明和方法主体，只有声明还有意义，而方法主体则没有存在的意义了。我们把没有方法主体的方法称为抽象方法。Java语法规定，包含抽象方法的类就是抽象类。

• 抽象方法：没有方法体的方法。
• 抽象类：包含抽象方法的类。
  抽象方法:
  使用abstract关键字修饰方法，该方法就成了抽象方法，抽象方法只包含一个方法名，而没有方法体

修饰符 abstract  返回值类型  方法名 (参数列表)

抽象类
如果一个类包含抽象方法，那么该类必须是抽象类。

public abstract  class Animal {public  abstract void  run();
}

抽象类的使用

继承抽象类的子类必须重写父类所有的抽象方法。否则，该子类也必须声明为抽象类。最终，必须有子类实现该父类的抽象方法，否则，从最初的父类到最终的子类都不能创建对象，失去意义。

public abstract  class Animal {public  abstract void  run();public void sleep(){System.out.println("在睡觉");}
}
public  class Cat extends Animal{@Overridepublic void run() {System.out.println("鸟悄的跑二");}
}
public class Test {public static void main(String[] args) {Cat cat = new Cat();cat.run();cat.sleep();}
}

此时的方法重写，是子类对父类抽象方法的完成实现，我们将这种方法重写的操作，也叫做实现方法。

抢红包

package com.weida.day02;/*** @ Author     ：Eric Lee* @ Date       ：Created in 23:33 2022/1/28* @ Description：* @ Modified By：* @ Version    : 1.0*/
public class User {private String userName;private double leftMoney;public User() {}public User(String userName, double leftMoney) {this.userName = userName;this.leftMoney = leftMoney;}public String getUserName() {return userName;}public void setUserName(String userName) {this.userName = userName;}public double getLeftMoney() {return leftMoney;}public void setLeftMoney(double leftMoney) {this.leftMoney = leftMoney;}@Overridepublic String toString() {return "User{" + "userName='" + userName + '\'' + ", leftMoney=" + leftMoney + '}';}
}

群主

package com.weida.day02;import java.util.ArrayList;/*** @ Author     ：Eric Lee* @ Date       ：Created in 23:35 2022/1/28* @ Description：* @ Modified By：* @ Version    : 1.0*/
public class QunZhu extends User{public QunZhu() {}public QunZhu(String userName, double leftMoney) {super(userName, leftMoney);}// 发等额红包public ArrayList<Double> send1(int money, int count){double leftMoney = this.getLeftMoney();if (leftMoney < money){return null;}// 更新this.setLeftMoney(leftMoney-money);// 等分money*=100;//每一份int m = money/count;int l = money%count;ArrayList<Double> list = new ArrayList<>();for (int i = 0; i < count-1; i++) {list.add(m/100.0);}if(l==0)list.add(m/100.0);elselist.add((m+l)/100.0);return list;}// 发手气红包//    public ArrayList<Double> send2(int money, int count){
//
//    }
}

成员

package com.weida.day02;import java.util.ArrayList;
import java.util.Random;/*** @ Author     ：Eric Lee* @ Date       ：Created in 23:44 2022/1/28* @ Description：* @ Modified By：* @ Version    : 1.0*/
public class Member  extends User{public Member() {}public Member(String userName, double leftMoney) {super(userName, leftMoney);}public void open(ArrayList<Double> list){Random random = new Random();int index = random.nextInt(list.size());Double money = list.remove(index);this.setLeftMoney(money + this.getLeftMoney());}
}

测试

package com.weida.day02;import java.util.ArrayList;/*** @ Author     ：Eric Lee* @ Date       ：Created in 23:05 2022/1/28* @ Description：* @ Modified By：* @ Version    : 1.0*/
public class TestRedPacket {public static void main(String[] args) {// User类   属性: username 和 leftMoney// QunZhu类  发红包  send(iny moeny, int count) 返回 ArrayList<Double> list// Member类   开红包  open (ArrayList<Double> list)  随机选一个
//        ArrayList<Object> list = new ArrayList<>();
//        list.remove()QunZhu qunZhu = new QunZhu("马化腾", 1000);ArrayList<Double> list = qunZhu.send1(100, 3);System.out.println(list);Member member1 = new Member("张三1", 10);Member member2 = new Member("张三2", 20);Member member3 = new Member("张三3", 30);member1.open(list);member2.open(list);member3.open(list);System.out.println(qunZhu);System.out.println(member1);System.out.println(member2);System.out.println(member3);}}