目录
1、继承
（1-10）
1、类是对对象的抽象，继承是对某一批类的抽象，从而实现对现实 世界更好的建模。
2、提高代码的复用性！
3、extands的意思是“扩展” 。子类是父类的扩展
4、不同的叫法：超类、父类、基类、子类、派生类
5、单继承
/*
继承：
表示父类跟子类之间的关系
当两个类或者多个类具备相同的属性和方法的时候，可以提取出来，变成父类，子类可以继承
Java中是单继承一个子类只能有单个父类
子类跟父类是is-a的关系
使用：
1、使用继承的时候需要用extends关键字
2、使用继承关系之后，父类中的属性和方法都可以在子类中进行使用（非私有属性和非私有方法）
3、java中是单继承关系（如果包含多个父类，同时父类中包含重名方法，无法决定该调用谁）
super：是 直接父类 对象的调用
用途：
1、可以在子类中调用父类中被子类覆盖的方法 super，父类方法名称
2、super在普通方法中使用的话，可以任意位置编写
3、super在构造方法中使用的话，就会调用父类的构造方法，一定要将super放在第一行
4、在构造方法中super关键字和this关键字（指的是不能同时使用this关键字调用重载的构造方法）不能同时出现
5、父类中私有的属性和方法都不能被调用，包括构造方法
6、子类的构造方法中都会默认使用super关键字调用父类的无惨构造方法，因此在定义类的时候，无论自己是否定义了其他构造方法，最好将无惨构造方法写上。
7、如何构造方法中显示的制定了super的构造方法，那么无惨的构造方法就不会被调用
总结：
1、在创建子类对象的时候一定会优先创建父类对象
2、所有的java类都具备一个顶级父类 称之为object，是所有类的根类
重写：
必须存在继承关系，当父类中的方法无法满足子类需求的时候可以选择使用重写的方式
*/
public class PetTest {
public static void main(String[] args) {
Dog dog=new Dog();
dog.setName("小白");
dog.setAge(10);
dog.setGender("雄性");
dog.setSound("汪汪~");
dog.show();
}
}public class Dog extends Pet{
private String sound;
public Dog(){
}
public Dog(String name,int age,String gender,String sound) {
super(name,age,gender);
this.sound = sound;
}
public String getSound () {
return sound;
}
public void setSound (String sound){
this.sound = sound;
}
public void show () {
// System.out.println("name:"+this.name+"age:"+this.age+"gender"+this.gender+"sound"+this.sound);
System.out.println("name:" + this.getName() + "age:" + this.getAge() + "gender" + this.getGender() + "sound" + this.sound);
}
}
public class Pet {
private String name;
private int age;
private String gender;
public Pet(){
}
public Pet(String name, int age, String gender) {
}
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 String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
}
2、super关键字
1、super是直接父类对象的引用
2、可以通过super来访问父类中被子类覆盖的方法或属性。
3、普通方法：没有顺序限制。可以随便调用。
4、构造函数中：
任何类的构造函数中，若是构造函数的第一行代码没有显式的调用super(...);那么 Java默认都会调用super();作为父类的初始化函数。 所以你这里的super();加不加 都无所谓。
访问父类构造方法
super（）；
super（name）；
访问父类属性
super.name
访问父类方法
super.print（）；
3、重写
必须要存在继承关系，当父类中的方法无法满足子类需求的时候可以选择使用重写的方法
注意：
重载：@overload
重写：@override
1、重写表示的是子类覆盖父类的方法，当覆盖之后，调用同样的方法的时候会优先调用子类
2、重写的方法名称，返回值类型，参数列表必须跟父类一致
3、子类重写的方法不允许比父类的方法具备更小的访问权限
父类：public 子类public
父类：protected 子类：public protected
父类：default 子类：public protected default
private不能被重写 private 是同一个类
父类的静态方法子类可以进行调用，但是子类不可以重写
继承符合is-a关系的设计使用继承
继承是代码重用的一种方式
将子类共有的属性和行为放到父类中
4、抽象类
java 中的对象是对现实世界的具象化，但是在现实世界中，某些并不具备实例化的意义，因此可以定义为抽象类 抽象类： 1、创建抽象类的时候需要添加abstract关键字 2、不能进行实例化，也就是不能new对象 3、抽象类中的某些方法需要子类进行更丰富的实现，父类实现没有意义，此时可以将抽象类 中的方法定义为抽象方法，没有具体的实现，质保函方法名称，返回值参数列表，访问修饰符 4、使用abstract关键字修饰的方法叫做抽象方法，可以不写方法的实现 5、子类在继承抽象父类的时候，必须要将父类中的抽象方法进行实现或者将子类也定义为抽象类 6、有抽象方法的一定是抽象类，但是抽象类中不一定包含抽象方法
//测试类
public class PetTest {
public static void main(String[] args) {
Dog dog=new Dog();
dog.print();
// Pet pet=new Pet(); 2、不能进行实例化，也就是不能new对象
}
}
//父类
public abstract class Pet {
// 1、创建抽象类的时候需要添加abstract关键字
private String name;
private int age;
public abstract void print();//抽象方法
// 3、抽象类中的某些方法需要子类进行更丰富的实现，父类实现没有意义，此时可以将抽象类
//中的方法定义为抽象方法，没有具体的实现，质保函方法名称，返回值参数列表，访问修饰符
// 4、使用abstract关键字修饰的方法叫做抽象方法，可以不写方法的实现
public void show(){
System.out.println("Pet show ....");
}
}
//子类
public class Dog extends Pet {
private String gender;
@Override//实现方法 如果不想实现方法 可以将本类抽象化但是不能被调用
public void print() {
System.out.println("dog print.. ..");
}
}5、 final关键字
final的使用： final 可以修饰变量：表示变量的值不可变 final 可以修饰的方法：表示方法不可以被重写 final 可以修饰类：表示类不可以被继承
//修饰变量
public class Finaledemo {
public static final int num=10;
public final void show(){
System.out.println("FinaDemo...");
}
public static void main(String[] args) {
// Finaledemo fd= new Finaledemo();
System.out.println(num);
// num=20; 错误
//final修饰的值不可变，最后输出只能为10
}
}//final修饰的类与方法
//类一：
public final class Finaledemo {
//final 修饰的类不能被继承
public static final int num=10;
//final修饰的方法
public final void show(){
System.out.println("FinaDemo...");
}
public static void main(String[] args) {
System.out.println(num);
}
}
//类二：
public class FinalSubClass extends Finaledemo{
//因为final修饰类一 所以此时的继承是不合法的
//@Override（重写） 错误
//public void show(){
//final修饰的方法不可以被重写
//当父类被final修饰的时候类不可以被继承
}6、object类A
object类是所有类的父类
源码的查看
==和equals（）
比较量基本类型变量的值是否相等
比较两个引用类型的值即内存地址是否相等，即是否指向同一对象
euals
两对象的内容是否一致
equals在图示中比较的是地址值，
而用来比较值的时候需要对equals进行重写
object中默认的为地址值相比
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Teacher teacher = (Teacher) o;
return age == teacher.age &&
Double.compare(teacher.salary, salary) == 0 &&
Objects.equals(name, teacher.name);
}
toString 通过hashCode算法默认为int 类型 默认调用地址值
加与不加toString的效果相同，都会调用父类object中的toString方法
public class Teacher {
private String name;
private int age;
private double salary;
public Teacher(){
}
public Teacher(String name,int age,double salary){
}
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 double getSalary(){
return salary;
}
public void setSalary(double salary){
this.salary=salary;
}
//toString的重写
@Override
public String toString() {
return "Teacher{" +
"name='" + name + '\'' +
", age=" + age +
", salary=" + salary +
'}';
}
public static void main(String[] args) {
Teacher t1=new Teacher("空衫",20,9000);
Teacher t2=new Teacher("空衫",20,9000);
System.out.println(t1.equals(t2));
System.out.println(t1);
}
}
重写toString方法：
默认返回值：包名+类名+@+哈希码
wait后5个方法与多线程相关（后面讲）
多个线程共享一个资源的时候
wait（1）进入后 用 wait（时间）进行控制wait（2）何时进入
继承深化：
== 方法名、形参列表相同。
返回值类型和异常类型，子类小于等于父类
访问权限：子类大于等于父类
构造方法调用顺序：
根据super的说明，构造方法第一句 总是：super(…)来调用父类对应的构造 方法。
先向上追溯到Object，然后再依次向下执行类的初始化块和构造方法，直 到当前子类为止。
3976
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
