面向对象-继承

一、类的继承

概念：面向在对象的精华在于继承，继承可在现有的功能上进行扩充，可快速开发出新的类，不需要写相同的代码，也是代码在利用的概念。

二、继承注意：

1、子类可继承父类非封装的属性和方法，封装的属性，子类可调用setter活getter方法活构造方法解决

2、同时，子类也可定义自己的属性和方法

3、子类不能同时继承多个父类

三、子类实例化过程：

1、子类对象在实例化之前首先调用父类的构造方法（对父类中的属性初始化）

2、再调用子类自己的构造方法

3、余下的子类和父类的普通方法，有子类实例对象决定调用哪个

四、子类复写方式：@Override

1、子类对父类的方法复写

原因：父类方法的代码不适合子类使用

注意：

①、子类定义了与父类中同名的方法

②、子类复写的方法不能拥有比父类方法更为严格的访问权限

总结：

当方法被覆写之后，子类对象调用的方法是被覆写后的方法

2、子类对父类的属性覆写

super关键字

概念：

super关键字可以从子类中调用父类中的构造方法、普通方法、属性

注意：

①、只能调用非封装的

②、super调用父类中的指定的构造方法操作，与this关键词用法一样，语句必须放在子类构造方法的首行

this和super区别：

	this	super
属性访问	访问本类中的属性，本类中没有此属性，则从父类中查找	访问父类中的属性
方法	访问本类中的方法，本类中没有此方法，则从父类中查找	直接访问父类中的方法
构造方法	调用本类构造，，必须放在构造方法的首行	调用父类构造，必须放在子类构造方法的首行

注：调用构造方法时，两者不能同时出现

重载和覆写的区别：

	重载（@Overload）	覆写（@Override）
定义	类中方法名称相同，参数类型或个数不同对权限没要求	子类和父类的方法名称，参数类型，返回值类型完全相同子类中被覆写的方法不能拥有比父类更为严格的权限
范围	发生在一个类中	发生在继承类中

五、继承格式：

class {}

class 子类  extends父类{}

代码部分：

package com.youcepre.java.object;


class Person{
    
    private String name;//属性
    private int age;
    
    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;
    }
    
    
}

class Student extends Person{
    private String school;

    public String getSchool() {
        return school;
    }

    public void setSchool(String school) {
        this.school = school;
    }
    
    
}

public class TestObject {

    public static void main(String[] args) {
        Student stu = new Student();
        stu.setName("lisi");
        stu.setAge(20);
        stu.setSchool("北邮");
        System.out.println("姓名：" + stu.getName() + " 年龄：" +stu.getAge() + " 学校："+stu.getSchool());
    
    }
}

六、抽象类

一、概念：包含一个抽象方法的类必须是抽象类，关键字:sbstract

1、抽象方法只需要声明而不需要实现（声明不能用private，否则子类不能实现）

2、抽象类至少有一个抽象方法，还可有普通方法

3、抽象类可以有抽象类的构造方法

4、抽象类必须被子类继承，子类必须重写抽象类的全部抽象方法

5、抽象类不能被直接实例化

6、抽象类专门当做父类，作用类似模板

七、接口

1、概念：接口是Java中一种特殊的类，是有全局常量和公共抽象方法锁组成

格式：

interface 接口名称{

       全局常量；

        抽象方法

}

代码：

package com.youcepre.java.object;

interface A{//定义接口A
	public static final String AUTHOR = "youceedu";
	public abstract void print();//public void print(),void print()
	public abstract String getInfo();//定义抽象方法
}


interface B{//定义接口B
	public void say();//定义抽象方法
}

class X implements A,B{//子类同时实现2个接口
	
	@Override
	public void say(){//覆写B接口中的抽象方法
		System.out.println("B--say()");
	}
	
	@Override
	public void print(){//覆写A接口中的抽象方法
		System.out.println("A--print()");
	}
	
	@Override
	public String getInfo(){//覆写A接口中的抽象方法
		return "test";
	}
}

public class TestObject {
	public static void main(String[] args) {
		X x = new X();
		x.say();
		x.getInfo();
	}
}

注：接口中抽象方法必须定义为public访问权限

案例1：接口继承多个接口

1、接口可1次继承多个接口    //类一次只能继承1个父类

2、一个子类可以同时实现多个接口，子类并且要全部覆写接口内的全部抽象方法

3、一个子类可以同时实现多个接口，可摆脱Java单继承局限

代码：

package com.youcepre.java.object;

interface A{//定义接口A
	public abstract void printA();
}

interface B{//定义接口B
	public abstract void printB();
}

interface C extends A,B{//定义接口C继承了A,B接口
	public abstract void printC();//接口C中存在3个抽象方法
}

class X implements C{//子类实现了C
	
	//抽象类和接口本身都有抽象方法,所以子类必须覆写
	
	@Override
	public void printA(){//覆写B接口中的抽象方法
		System.out.println("printA()");
	}
	
	@Override
	public void printB(){//覆写A接口中的抽象方法
		System.out.println("printB()");
	}
	
	@Override
	public void printC(){//覆写A接口中的抽象方法
		System.out.println("printC()");
	}
}

public class TestObject {
	public static void main(String[] args) {
		X x = new X();
		x.printA();
	}
}

案例2：子类继承普通类/抽象类并实现接口/

格式：

class   子类   extends  抽象类  implements 接口A，接口B{

}

代码：

package com.youcepre.java.object;

interface A{//定义接口A
	public static final String AUTHOR = "youceedu";
	public abstract void print();//public void print(),void print()
	public abstract String getInfo();//定义抽象方法
}


abstract class B{
	public abstract void say();
}

class X extends B implements A{//子类同时实现2个接口
	
	//抽象类和接口本身都有抽象方法,所以子类必须覆写
	
	@Override
	public void say(){//覆写B接口中的抽象方法
		System.out.println("B--say()");
	}
	
	@Override
	public void print(){//覆写A接口中的抽象方法
		System.out.println("A--print()");
	}
	
	@Override
	public String getInfo(){//覆写A接口中的抽象方法
		return "test";
	}
}

public class TestObject {
	public static void main(String[] args) {
		X x = new X();
		x.say();
		x.getInfo();
	}
}

案例3：抽象类实现接口

格式：

abstract   class  B   implements  A

代码：

package com.youcepre.java.object;

interface A{//定义接口A
	public static final String AUTHOR = "youceedu";
	public abstract void print();//public void print(),void print()
	public abstract String getInfo();//定义抽象方法
}

abstract class B implements A{//抽象类实现接口
	public abstract void say();//此时抽象类存在3个抽象方法
	
	@Override
	public void print(){//覆写A接口中的抽象方法
		System.out.println("A--print()");
	}
	
	@Override
	public String getInfo(){//覆写A接口中的抽象方法
		return "test";
	}

}

class X extends B{//子类同时实现2个接口
	
	//抽象类和接口本身都有抽象方法,所以子类必须覆写
	
	@Override
	public void say(){//覆写B接口中的抽象方法
		System.out.println("B--say()");
	}
}

public class TestObject {
	public static void main(String[] args) {
		X x = new X();
		x.say();
		x.getInfo();
	}
}

注：①、抽象类可以实现接口，但接口不允许继承抽象类，允许一个接口继承多个接口

        ②、同类型都可继承（类-接口）extends ，不同类型只能用实现--implements

八、抽象类与接口区别：