继承与接口
1）构造器 2）方法重载 3）继承 4）方法重写 5）自动转型 6）多态
一、构造器
定义：用于构造当前类的对象的函数
格式：public 类名(){}
注意点：1）任何一个类都必然会有构造器，一般默认不写出来，默认定义
2）创建对象过程中，一定会调用当前类的构造函数
例如：
public class student{
//默认构造器，暗含的，不写也有
public student{
System.out.pirntln("默认构造器");
}
public String name;
//自己编写的构造器
public void study(){
System.out.println("我在学习");
}
}
3）构造函数有返回值,返回的是当前对象的内存地址
publc class test{
public static void main(String[] args){
student stu1=new student();
student stu2=new student();
stu1.name="孙悟空";
stu2.name="哪吒";
stu1=stu2;
stu1.name="玉帝";
System.out.println(stu1.name);
System.out.println(stu2.name);
}
}
因为stu1的指向改变了，从而指向stu2原来的指向，
当通过指向改变内存时，stu2得到的就是改变后的。
所以这代码的结果度是玉帝
4）在java中，对象之间的赋值，就是地址之间的赋值（引用传递）
二、方法重载
定义：同一个类中，多个方法的方法名相同，参数不同（类型、顺序、个数）,互为重载方法
注意：
1）普通函数重载
public void study(){
System.out.println("学生学习");
}
public void study(int num){
System.out.println("学生学习");
}
public void study(String n){}
}
2）构造函数重载：提供多种创建对象的方式
i.创建一个对象只能调用一个构造函数
ii.如果构造方法被重载了，默认构造方法就不存在了，如果说还要用默认无参的，则必须显性写出来
iii.作用：初始化当前类的对象属性
public class student{
public student(){}
public String name;
public int age;
public int height;
public String address;
//方法重载
public student(String n,int num,int h,String add){
name=n;
age=num;
height=h;
address=add;
}
}
三、继承
定义：类与类之间的继承（子类、父类），子类继承父类的属性和方法
格式：public class 子类类名 extends 父类类名{}
应用场景：当一个类需要用到另外一个类中的属性，而自己不想重新定义的时候，就可以通过继承关系，
直接从另外一个类中获取过来
注意：继承是单继承的，一个子类只能有一个父类，不能同时继承多个
但是可以多层继承
public class father{
public void active(){
System.out.println("吃饭是个好习惯");
}
}
--------------------------------------
public class son extends father{
public void study(){
System.out.println("学习是个好习惯");
}
public static void main(String[] args){
son s=new son();
s.active();
s.study();
}
}
------------------------------------------
public class grandson extends son{
public static void main(String[] args){
grandson gs=new grandson();
gs.active();
gs.study();
}
}
------------------------------------------
第三个代码的结果是：吃饭是个好习惯
学习是个好习惯
四、方法重写
前提条件：一定在继承的条件下进行
定义：子类重写父类的方法，方法名、参数、返回类型都一致
作用：修改父类定义的过程，对父类继承过来的函数进行修改（过程）
子类如果重新定义了父类的函数，则把父类的函数覆盖掉
public class father{
public void active(){
Sytem.out.println("父亲吃饭");
}
}
----------------------------------------------
public class son extends father{
public void active(){
System.out.println("儿子吃饭");
}
}
-----------------------------------------------
五、自动转型
定义：子类的对象会自动转型为父类的类型
格式：父类的类型 对象名 = new 子类类型();
注意：转型后的对象，是父类类型的对象
public class test{
public static void main(String[] args){
father A=new father();
father B=new son();
A.active();
B.avtive();
}
}
转型之后，不能调用子类特有的行为
转型后的对象注意点：如果子类重写了父类的方法，
则执行重写后的，如果没有重写，则执行父类自己的，
一定不能调用子类特有的方法
六、多态（现象）
多个同一个类型的对象，调用同一个方法的时候，执行的过程不一样
多态现象出现->自动转型+方法重写->继承
1）构造器 2）方法重载 3）继承 4）方法重写 5）自动转型 6）多态
一、构造器
定义：用于构造当前类的对象的函数
格式：public 类名(){}
注意点：1）任何一个类都必然会有构造器，一般默认不写出来，默认定义
2）创建对象过程中，一定会调用当前类的构造函数
例如：
public class student{
//默认构造器，暗含的，不写也有
public student{
System.out.pirntln("默认构造器");
}
public String name;
//自己编写的构造器
public void study(){
System.out.println("我在学习");
}
}
3）构造函数有返回值,返回的是当前对象的内存地址
publc class test{
public static void main(String[] args){
student stu1=new student();
student stu2=new student();
stu1.name="孙悟空";
stu2.name="哪吒";
stu1=stu2;
stu1.name="玉帝";
System.out.println(stu1.name);
System.out.println(stu2.name);
}
}
因为stu1的指向改变了，从而指向stu2原来的指向，
当通过指向改变内存时，stu2得到的就是改变后的。
所以这代码的结果度是玉帝
4）在java中，对象之间的赋值，就是地址之间的赋值（引用传递）
二、方法重载
定义：同一个类中，多个方法的方法名相同，参数不同（类型、顺序、个数）,互为重载方法
注意：
1）普通函数重载
public void study(){
System.out.println("学生学习");
}
public void study(int num){
System.out.println("学生学习");
}
public void study(String n){}
}
2）构造函数重载：提供多种创建对象的方式
i.创建一个对象只能调用一个构造函数
ii.如果构造方法被重载了，默认构造方法就不存在了，如果说还要用默认无参的，则必须显性写出来
iii.作用：初始化当前类的对象属性
public class student{
public student(){}
public String name;
public int age;
public int height;
public String address;
//方法重载
public student(String n,int num,int h,String add){
name=n;
age=num;
height=h;
address=add;
}
}
三、继承
定义：类与类之间的继承（子类、父类），子类继承父类的属性和方法
格式：public class 子类类名 extends 父类类名{}
应用场景：当一个类需要用到另外一个类中的属性，而自己不想重新定义的时候，就可以通过继承关系，
直接从另外一个类中获取过来
注意：继承是单继承的，一个子类只能有一个父类，不能同时继承多个
但是可以多层继承
public class father{
public void active(){
System.out.println("吃饭是个好习惯");
}
}
--------------------------------------
public class son extends father{
public void study(){
System.out.println("学习是个好习惯");
}
public static void main(String[] args){
son s=new son();
s.active();
s.study();
}
}
------------------------------------------
public class grandson extends son{
public static void main(String[] args){
grandson gs=new grandson();
gs.active();
gs.study();
}
}
------------------------------------------
第三个代码的结果是：吃饭是个好习惯
学习是个好习惯
四、方法重写
前提条件：一定在继承的条件下进行
定义：子类重写父类的方法，方法名、参数、返回类型都一致
作用：修改父类定义的过程，对父类继承过来的函数进行修改（过程）
子类如果重新定义了父类的函数，则把父类的函数覆盖掉
public class father{
public void active(){
Sytem.out.println("父亲吃饭");
}
}
----------------------------------------------
public class son extends father{
public void active(){
System.out.println("儿子吃饭");
}
}
-----------------------------------------------
五、自动转型
定义：子类的对象会自动转型为父类的类型
格式：父类的类型 对象名 = new 子类类型();
注意：转型后的对象，是父类类型的对象
public class test{
public static void main(String[] args){
father A=new father();
father B=new son();
A.active();
B.avtive();
}
}
转型之后，不能调用子类特有的行为
转型后的对象注意点：如果子类重写了父类的方法，
则执行重写后的，如果没有重写，则执行父类自己的，
一定不能调用子类特有的方法
六、多态（现象）
多个同一个类型的对象，调用同一个方法的时候，执行的过程不一样
多态现象出现->自动转型+方法重写->继承