继承(extends)
1：继承(extends)
父类（超类、基类）：被继承特性的类就是父类。
子类（派生类、导出类）：在原有类的基本上派生出来的新类。
子类可以添加自己新的属性和方法。父类的属性和方法也都继承下来了！
(1)继承的体系结构：就是对要描述的事物进行不断的向上抽取，就出现了体系结构。
**先学习顶层内容，因为它是共性内容。
**一般使用的时候使用的是底层的类。
(2)继承的好处：
A：继承的出现，提高了代码的复用性。
B：继承的出现，让类与类之间产生了关系，extends来表示，
这个关系的出现，为后面我们讲面向对象的第三个特点多态打下了基础。
(3)特点
A：java只支持单继承(其实确切的说是java对多继承进行了优化，避免了安全问题)。
B：java支持多重(层)继承。
(4)注意：
A：子类可以直接访问父类中的非私有的属性和行为。
B：不要仅为了获取其他类中部分功能而去继承。
C：类与类之间要有所属( " is a " )关系，xx1是xx2的一种。
**如何判断A和B是否有继承关系？
**A如果继承B，那么就可以说A是B的一种。
2：继承后子父类之间成员的关系
(1)成员变量
class Father
{
int num1 = 5;
}
class Son extends Father
{
int num1 = 20;
int num2 = 10;
public void show()
{
int num1 = 30;
System.out.println("num1:"+num1);
System.out.println("num2:"+num2);
//局部范围内有的变量，如果我想使用成员变量，怎么办？this
System.out.println("this num1:"+this.num1);
//就想子类中访问父类中和子类同名的变量super
System.out.println("father num1:"+super.num1);
}
}
总结：使用子类中的成员变量时，首先看局部有没有和成员变量同门的，如果有就是用局部的。
其实，在子类的成员变量里面找，如果有，直接输出。
最后，在父类中找同名的变量，如果有，就输出父类的值。否则报错。
this和super的区分：
**this代表本类对象的引用
super代表父类的内存空间的标识。
**this可以用于区分局部变量和成员变量同名的情况。
super可以用于区分子类和父类成员变量同名的情况。
**一般，子类中不会出现和父类同名的成员变量。面试可能问到。
(2)成员方法
class Father
{
public void show()
{
System.out.println("father show");
}
}
class Son extends Father
{
public void show()
{
System.out.println("son show");
}
public void show1()
{
System.out.println("son show1");
}
}
总结：在使用子类的成员方法时：首先在子类中找，其次在父类中找。否则，报错。
super可以在子类中使用父类的成员方法。
子类中存在和父类成员方法同名的这种现象，叫做重写，复写，覆盖。
重写(override)和重载(overload)的区别：
重载的特点：
**在同一类中。
**方法名相同，参数列表不同。
重写的特点：
**要有继承关系。在子父类中
**方法的声明相同。(方法名和参数列表都相同)
***覆盖时，子类方法权限一定要大于等于父类方法权限
***静态只能覆盖静态。
(3)构造方法
class Father
{
Father(){}
Fahter(int age)
{
System.out.println("father age:"+age);
}
}
class Son extends Father
{
Son()
{
//默认这里有一个东西 super();
//this(20);
System.out.println("son");
}
Son(int age)
{
super(age);
System.out.println("son age:"+age);
}
}
Son s = new Son(); //father;son
Son s = new Son(20);//father;son age:20
总结：子类中所有的构造方法默认都会访问父类中空参数的构造方法。
**因为每一个构造方法的第一行都有一条默认的语句super();
当父类中没有空参数的构造方法时，子类的构造函数必须通过this
或者super语句指定要访问的构造方法。类手动提供无参构造方法。
this(...):调用本类中的构造方法
super(...):调用父类中的构造方法
以前：构造方法用于创建对象，并进行初始化。
class Person
{
Person(){}
Person(int age)
{
this.age = age;
}
Person(int age,String name)
{
this(age);
//this.age = age;
this.name = name;
}
}
//Person p =new Person(); //系统默认给出无参构造
//当你手动给出构造方法后，系统就不会再给出默认的空的构造方法。
手动无参数，如果你想给属性赋值或者做一些初始化，无参你别删不就行了吗。
class Demo
{
private String name;
Demo(){}
public void setName(String name)
{
this.name = name;
}
public String getName()
{
return name;
}
}
练习继承语法
1.每个属性都要有set/get方法
两个构造器，无参和有参(有几个属性就有几个参数)
toString()，把所有的属性加加号连接，返回一个字符串。
Student、Teacher
抽取出Person
修改Student和Teacher，继承Person类
再写Employee类。
Student：int number，String name，int age，String sex
Teacher：int id, String name, int age, String sex, double salary
Person：String name，int age，String sex
Employee：int id, double salary
修改Teacher，因为它是一个员工。它的爸爸就是Employee了，人就是爷爷！
2 画出上面例子的继承层次图
可以尝试再添加一些类，例如：
继承了什么
构造器是继承不了的。
private的属性和方法也是无法继承的。（private属性是不能用，但其实子类是有的）（如果有人考你，子类是否继承了父类的private属性，你回答“没有”）
其他的属性和方法就都继承下来了。
多态性（崔老师）
员工类，有一个返回年终奖的方法，但这个方法是空的。
经理，重写了这个方法；
秘书，重写了这个方法；
程序员，重写了这个方法；
业务员，也重写了了这个方法；
我们用一个员工数组来把这些经理、秘书、等等都放这个数组中。
循环遍历这个数组，调用每个元素的返回年终奖方法，做累加和，计算年底要发的工资。
员工[] es = new 员工[100];//这是一百个员工引用！
es[0] = new 经理();//向上转型
es[1] = new 秘书();
….
es[0].返回年终奖()，这是调用经理的方法。
1 是一个（is a），向上转型
可以用父类的引用，指向子类的实体对象。
只有向上转型了，才会有多态，所以，我们经常会说向上转型，就是多态！
2 调用的是子类的方法还是父类的方法
调用谁的方法，由实体类型来决定，而不是引用类型。
3 向上转型后能调用的方法个数被引用类型限制
调用的方法是实体的方法，但能调用的方法个数受引用类型的限制。
4 向下转型不安全
向上转型：用父类的引用指向子类引用指定的实体。这是安全的！
向下转型：用子类的引用指向父类引用指向的实体。这是不安全的！
非静态
S.fun() p.fun()调用谁的方法，由实体类型来决定，而不是引用类型。
S.fun() p.fun()的区别p的那个只能调用重写父类的方法，s既可以调用重写，也可以调用自己的
静态的（static）
谁调用的就用谁！
5 判断“是一个”的关系（instanceof运算符）
6 多态调用的概念
重载：编译器确定要调用的是哪一个方法。同一条调用语句，但调用的哪个重载版本的方法是多态的！
重写：JVM确定调用的是哪一个方法。同一个类型的引用，调用的是哪个类的方法是多态的！
public void fun(byte b) {}
public void fun(int i) {}
byte b = 1;
fun(b);
7 运行时多态的前提
继承或实现；
重写方法
向上转型，然后调用重写方法。
错误的多态理解
1 属性不是多态的
2 static方法不是多态的
3 private方法不是多态的
多态(沙老师)
(1)某一类事物的多种存在形态。
**方法重载(静态多态)
**方法重写(动态多态,对象多态)
(2)对象多态的前提
A：类与类(或接口)要有继承(或实现)关系。
B：一定要有方法的重写。
C：一定要有父类或者接口的引用指向子类的对象。
(3)多态思想：可以指挥同一类型的一批对象做事情。多态的出现让我们复杂的问题简单化了。
A：Animal Cat Dog
**method(Animal a){a.eat();}
B：同学们吃饭
C：士兵打仗(擡枪，瞄准，射击)。
(4)多态中成员的特点：(我们只研究特殊的，就是说名字一样的东西)
Fu f = new Zi();
A：成员变量：编译和运行都看Fu。
B：非静态方法：编译看Fu，运行看Zi。
C：静态方法：编译和运行都看Fu。
举例： 动物的例子：
向上转型
Animal a = new Cat();
a.eat();
//a.catchMouse();
向下转型
Cat c = (Cat)a;
c.eat();
c.catchMouse();
//向上转型
Animal a = new Dog();
//向下转型 转换异常
//Cat c = (Cat)a;
Dog d = (Dog)a;
孔爹的例子：
孔爹:教课(Java)
孔子:教课(论语),看小说(),打游戏()。
孔爹 k = new 孔子();//穿上他爹衣服,就跟着去了
k.教课(论语)。
//k.看小说();
孔子 kz = (孔子)k;//把衣服脱了
kz.教课(论语);
kz.看小说();
kz.打游戏();
final可以用来修饰什么呢？
(1)final可以用来修饰类：被fainl修饰的类不能被继承。
(2)final可以用来修饰成员方法：被final修饰的成员方法不能被重写。
(3)final可以用来修饰变量：被final修饰的变量为常量，值不能被修改。
常量的命名规范：要求大写。
final int PI = 3.14;
final难道必须声明的时候就赋值。
一般来说，是这样的。但是特殊情况：在构造方法可以给final修饰的变量赋值。
Object
(1)Object类：java中所有类的父类。它是java类体系结构中的根类。
java中的类都直接或者间接继承自Object类。
(2)学习了里面的几个方法:重点掌握 toString(),equals()。
boolean equals(Object o)：比较当前对象和参数对象是否相等！但这个比较没有什么意义！因为我们希望比较的不是两个引用是否指向同一个实体，而是想知道这两个实体是否一样！
int hashCode()：返回一个整数，它表示一个对象实体的地址。或者你可以理解为它是地址运算后的结果。这个方法会在集合时再讨论！
String toString()：返回一个对当前对象的描述，即字符串形式的描述！Object类的toString()返回的是当前对象的“类全名 + @ + 16进制的hashCode()”
Class getClass()：返回当前对象的类型信息，其中返回值Class类型，它就是方法区的.class文件对应体！
A：boolean equals(Object obj)
指示其他某个对象是否与此对象“相等”。
B：String toString()
返回该对象的字符串表示。
C：int hashCode()
返回该对象的哈希码值。
D：Class<?> getClass()
返回此 Object 的运行时类。
E：protected void finalize() 了解
当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。
**final,finally,finalize
(3)重点看下面两个方法
//重写toString()方法
public String toString()
{
//return "HelloWorld";
return "name:"+name+",age"+age;
}
//重写Object的equals方法
public boolean equals(Object obj)//s2--obj
{
//为了提高效率
if(this == obj)
{
return true;
}
//为了程序的健壮性
if(!(obj instanceof Student))//格式：对象 instanceof 具体的类名
{
return false;
}
Student s = (Student)obj;
if(this.age==s.age)
{
return true;
}
else
{
return false;
}
}
"equals"和"=="用法区别？
equals()是一个方法，来自Object类
==比较运算符，叫关系运算符！
==用来比较基本类型，但比较引用类型，那么比较的是两个引用的地址是否相同
equals()是一个方法，它比较当前对象和参数对象是否相等，在Object类中，就是使用==来比较的，
所以，调用Object类的equals()和使用==比较，是相同效果！
但，很多子类都重写了equals()方法，那么比较的效果就与==不同了。
结论：基本类型使用==比较
引用类型使用equals()比较！