继承的基本概念:
书写格式:
package demo01;
/*
父类定义格式:
public class 类名称{}
子类定义格式:
public class 子类名称 extends 父类名称{}
*/
public class Demo01Extends {
public static void main(String[] args) {
Teacher tec=new Teacher();
tec.method();
}
}
package demo01;
/*
定义一个父类
*/
public class Employee {
public void method(){
System.out.println("父类方法执行");
}
}
package demo01;
/*
定义一个子类
*/
public class Teacher extends Employee
{
}
成员变量访问规则:
package demo02;
/*
继承的成员变量访问规则
直接点成员变量:看等号前
用成员方法调用:看是谁的方法
*/
public class Demo01Extends {
public static void main(String[] args) {
Fu fu=new Fu();
System.out.println(fu.num);//100
Zi zi=new Zi();
System.out.println(zi.num);//200
fu.methodFu();//1000
zi.methodZi();//2000
zi.methodFu();//1000
}
}
package demo02;
public class Fu {
int numFu=10;
int num=100;
public void methodFu(){
System.out.println(1000);
}
}
package demo02;
public class Zi extends Fu{
int numZi=20;
int num=200;
public void methodZi(){
System.out.println(2000);
}
}
区分重名变量的方法:
package demo03;
/*
区分子类变量重名的方法
局部变量:直接写
子类成员变量:this.变量名
父类成员变量:super.变量名
*/
public class Demo01Extends {
public static void main(String[] args) {
Zi zi=new Zi();
zi.method();
}
}
package demo03;
public class Fu {
int num=10;
}
package demo03;
public class Zi extends Fu{
int num=20;
public void method(){
int num=30;
System.out.println(num);
System.out.println(this.num);
System.out.println(super.num);
}
}
成员方法重名:
package demo04;
/*
成员方法重名,往上找
方法的覆盖(Override):在继承关系中,方法名称一样,参数列表也一样 ,也叫重写
区别于重载(Overload):方法名称一样,参数列表不一样
*/
public class Demo01Extends {
public static void main(String[] args) {
Zi zi =new Zi();
zi.method();
}
}
package demo04;
public class Fu {
public void method(){
System.out.println("父类重名方法执行");
}
}
package demo04;
public class Zi extends Fu {
public void method(){
System.out.println("子类重名方法执行");
}
}
/*
注意事项:
1.Overload父类和子类保持方法名和参数列表一致,可以用@Overload测试
2.父类返回值类型大于等于子类Object>=String
3.子类标识符大于等于父类 public>protected>(default)>private
*/
方法的覆盖和重写:
package demo05;
public class Demo02Extends {
public static void main(String[] args) {
Phone phone =new Phone();
phone.call();
phone.send();
phone.show();
NewPhone newP=new NewPhone();
newP.show();
}
}
package demo05;
public class Phone {
public void call(){
System.out.println("打电话");
}
public void send(){
System.out.println("接电话");
}
public void show(){
System.out.println("来电显示");
}
}
package demo05;
public class NewPhone extends Phone {
@Override
public void show(){
super.show();
System.out.println("显示名字");
System.out.println("显示头像");
}
}
package demo06;
/*
构造方法的访问:
1.先调用父类,后调用子类
2.子类构造不能多次调用
3.子类可以通过super关键字来调用父类重载构造
*/
public class Demo01Extends
{
public static void main(String[] args) {
Zi zi=new Zi();
}
}
/*
这是一个有参构造
这是一个子类构造
*/
package demo06;
public class Fu
{
public Fu(){
System.out.println("这是一个无参构造");
}
public Fu(int num){
System.out.println("这是一个有参构造");
}
}
package demo06;
public class Zi extends Fu
{
public Zi (){
super(20);
System.out.println("这是一个子类构造");
}
}
super关键字的三种用法
package demo07;
/*
super关键字的三种用法
1.子类成员方法访问父类成员变量
2.子类成员方法访问父类成员方法
3.子类构造方法访问父类构造方法
*/
public class Zi extends Fu {
int num=20;
public void method(){
super.method();
System.out.println(super.num);
}
public Zi(){
super();
}
}
package demo07;
public class Fu {
int num=10;
public void method(){
System.out.println("父类方法");
}
}
this关键字的三种用法
package demo07;
/*
this关键字的三种用法
1.成员方法访问本类成员变量
2.成员方法访问本类成员方法
3.构造方法访问本类构造方法
*/
public class Zi extends Fu {
int num=20;
public void method(){
int num=30;
System.out.println(num);
System.out.println(this.num);
}
public void methodA(){
System.out.println("AAA");
}
public void methodB(){
this.methodA();
System.out.println("BBB");
}
public Zi(){
this(20);
}
public Zi(int num){
}
}
super和this的内存图:
package demo08;
public class Demo {
public static void main(String[] args) {
Zi zi=new Zi();
zi.method();
zi.show();
}
}
package demo08;
public class Fu {
int num=10;
public void method(){
System.out.println("父类方法");
}
}
package demo08;
public class Zi extends Fu {
int num=20;
public void method(){
int num=30;
System.out.println(num);
System.out.println(this.num);
System.out.println(super.num);
}
public void show(){
super.method();
System.out.println("子类方法");
}
}
继承的3个特点:
1.单继承
2.多级继承
3.一父可以有多子
抽象的概念:
抽象方法的定义
/*
抽象方法:在public后面加abstract,后面没有大括号
抽象类:在public后面加abstract
*/
public abstract class demo09 {
public abstract void method();
public void main(){
}
}
抽象方法的使用:
/*
抽象方法:在public后面加abstract,后面没有大括号
抽象类:在public后面加abstract
如何使用抽象类和抽象方法
1.抽象方法不能直接new
2.写一个子类继承父类
3.子类覆盖重写,去abstract,加大括号
4.创建子类对象使用
*/
public abstract class demo09 {
public abstract void method();
public void main(){
}
}
public class Cat extends demo09
{
public void method(){
System.out.println("猫吃鱼");
}
}
public class Demo01 {
public static void main(String[] args) {
Cat cat =new Cat();
cat.method();
}
}
注意事项:
package demo09;
/*
抽象类不可以new
抽象子类必须重写抽象父类的所有抽象方法
*/
public class Demo01 {
public static void main(String[] args) {
Dog2Ha ha=new Dog2Ha();
ha.eat();
ha.sleep();
Golden gol=new Golden();
gol.eat();
gol.sleep();
}
}
package demo09;
public abstract class Animal {
public abstract void eat();
public abstract void sleep();
}
package demo09;
public abstract class dog extends Animal {
@Override
public void sleep(){
System.out.println("呼呼呼");
}
}
package demo09;
public class Dog2Ha extends dog{
@Override
public void eat(){
System.out.println("吃屎");
}
}
package demo09;
public class Golden extends dog {
public void eat(){
System.out.println("吃骨头");
}
}
练习:发红包
代码:p170