学习目标：

视频p150-p193

继承
修饰符
多态
抽象与接口
内部类
目录

继承

1.1 继承概述

1.2 继承的优缺点

1.3 继承中变量的访问特征

1.4 super

1.5 继承中构造方法的访问特征

1.6 继承中成员方法的访问特征

1.7 super的内存图

1.8 方法重写

1.9 重写方法的注意事项

1.10 继承注意事项

案例一：师生

案例二:猫和狗

修饰符

1、包

2、导包

2.1 导包的概述和使用

3、修饰符

3.1 修饰符的分类

3.2 权限修饰符

3.3 状态修饰符

多态

1.1 多态概述

1.2 多态中成员访问特征

1.3 多态的优缺点

1.4 多态转型

1.5 多态转型内存分析

1.6 案例一:猫和狗

抽象与接口

1、抽象类

1.1 抽象类概述

1.2 抽象类的特点

1.3 抽象成员特征

案例：猫和狗

2、接口

2.1 接口概述

2.2 接口的特点

2.3 多态形式和前提总结基于抽象类和接口

2.4 接口的成员特点

案例：猫和狗

2.5 类和接口的关系

2.6 抽象类和接口的区别

案例：运动员和教练

3、面向对象中的形参和返回值

1.1 类名作为形参和返回值

1.2 抽象类名作为形参和返回值

1.3 接口名作为形参和返回值

内部类

1.1 内部类概述

1.2 成员内部类

1.3 局部内部类

1.4 匿名内部类

1.5 匿名内部类在开发中的使用

学习内容：

继承

1.1 继承概述
1.2 继承的好处和弊端
1.3 继承中变量的访问特点

子类和父类中都有的话，会使用子类的。

方法中使用变量时，首先在方法内部中找，再去本类成员中找，再去父类的成员中去找。

*不考虑父亲的父亲*

1.4 super

public class ZI extends FU{
    public int age=20;
    
    public void show()
    {
        int age=30;
        System.out.println(age);
        //如果想访问本类中的成员变量
        System.out.println(this.age);
        //如果想访问父类中的成员变量
        System.out.println(super.age);
    }
}

1.5 继承中构造方法的访问特点

//测试类
public class Demo {
    public static void main(String[] args) {
        ZI z=new ZI();
        
        ZI z2=new ZI(age);
    }
}

结果：

继承中成员方法的访问特点
1.7 super的内存图
1.8 方法重写

1.9 方法重写的注意事项
1.10 继承的注意事项
案例一：老师和学生
案例二：猫和狗

修饰符

1、包
2、导包
2.1 导包的概述和使用
3、修饰符
3.1 修饰符的分类

权限修饰符＋状态修饰符

3.2 权限修饰符
3.3 状态修饰符

多态

1.1 多态概述

//父类
public class Animal {
    public void eat()
    {
        System.out.println("动物吃东西");
    }
}

//子类
public class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("猫吃老鼠");
    }
}

//测试类
public class AnimalDemo {
    public static void main(String[] args) {
             Animal a=new Cat();
    }
}

1.2 多态中成员访问特点

1.3 多态的好处和弊端

1.4 多态中的转型

public class AnimalDemo {
    public static void main(String[] args) {
        //多态
        Animal a =new Cat();//向上转型：把子类对象赋值给父类的引用
        a.eat();
    }

    //向下转型
    Cat c=(Cat) a;
    c.eat();
    c.playGame();
}

抽象类与接口

1、抽象类

1.1 抽象类概述

1.2 抽象类的特点

1.3 抽象类的成员特点

案例：猫和狗

2、接口

2.1 接口概述

2.2 接口的特点

2.4 接口的成员特点

案例：猫和狗

public interface Jumpping {
    public abstract void jump();
}

public class Cat extends Animal implements Jumpping{
    public Cat(){}

    public Cat(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }

    @Override
    public void jump() {
        System.out.println("猫猫可以调高了");
    }
}

public abstract class Animal {
    private String name;
    private int age;

    public Animal() {
    }

    public Animal(String name, int age) {
        this.name = name;
        this.age = 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;
    }

    public abstract void eat();
}

public class AnimalDemo {
    public static void main(String[] args) {
        //创建对象，调用方法。
        Jumpping j=new Cat();
        j.jump();
        System.out.println("-----------");

        Animal a=new Cat();
        a.setName("加菲");
        a.setAge(5);
        System.out.println(a.getName()+","+a.getAge());
        a.eat();
        System.out.println("-----------");

        a=new Cat("加菲",5);
        System.out.println(a.getName()+","+a.getAge());
        a.eat();
        System.out.println("-----------");

        //以后使用时最多的还是这个具体的子类实现类，因为它里面有最多的方法。
        Cat c=new Cat();
        c.setName("加菲");
        c.setAge(5);
        System.out.println(c.getName()+","+c.getAge());
        c.eat();
        c.jump();

    }
}

2.5 类和接口的关系

Java中可以有多继承，但那是体现在接口上的。

2.6 抽象类和接口的区别

案例：运动员和教练

//说英语接口
public interface SpeakingEnglish {
    public abstract void speak();
}

//定义抽象 人 类
public abstract class Person {
    private  String name;
    private int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = 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;
    }

    public abstract void eat();
}

//定义抽象 教练 类
public abstract class Coach extends Person{
    public Coach(){}

    public Coach(String name, int age) {
        super(name, age);
    }

    public abstract  void teach();
}

//定义抽象运动员类
public abstract class Player extends Person{

    public Player(){}

    public Player(String name,int age){
    super(name,age);
    }

    public abstract void study();
}

//定义具体教练

public abstract class BBcoach extends Coach{
    public BBcoach() {
    }

    public BBcoach(String name, int age) {
        super(name, age);
    }

    @Override
    public void teach() {
        System.out.println("篮球教练教三步上篮");
    }

    @Override
    public void eat() {
        System.out.println("篮球教练吃羊肉串");
    }
}

//第二个
public abstract class PPcoach extends Coach implements SpeakingEnglish{
    public PPcoach() {
    }

    public PPcoach(String name, int age) {
        super(name, age);
    }

    @Override
    public void teach() {
        System.out.println("乒乓球教练教发球接球");
    }

    @Override
    public void eat() {
        System.out.println("乒乓球教练喝蔬菜粥");
    }

    @Override
    public void speak() {
        System.out.println("乒乓球教练说英语");
    }
}

//定义具体运动员
public class BasketPlayer extends Player{
    public BasketPlayer() {
    }

    public BasketPlayer(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("篮球运动员吃牛肉饼");
    }

    @Override
    public void study() {
        System.out.println("篮球运动员学投篮");
    }
}

//第二个
public class PINGPlayer extends Player implements SpeakingEnglish{
    public PINGPlayer() {
    }

    public PINGPlayer(String name, int age) {
        super(name, age);
    }

    @Override
    public void study() {
        System.out.println("乒乓球运动员学发球接球");
    }

    @Override
    public void eat() {
        System.out.println("乒乓球运动员吃小白菜");
    }

    @Override
    public void speak() {
        System.out.println("乒乓球运动员说英语");
    }
}

//定义测试类
public class ALLDemo {
    public static void main(String[] args) {
        PINGPlayer ppp=new PINGPlayer();
        ppp.setName("小王");
        ppp.setAge(16);
        System.out.println(ppp.getName()+","+ppp.getAge());
        ppp.eat();
        ppp.study();
        ppp.speak();
        System.out.println("----------");

        BasketPlayer bbb=new BasketPlayer();
        bbb.setName("小明");
        bbb.setAge(18);
        System.out.println(bbb.getName()+","+bbb.getAge());
        bbb.eat();
        bbb.study();
    }
}

测试结果：

3、面向对象中的形参和返回值

1.1 类名作为形参和返回值

1.2 抽象类名作为形参和返回值

public abstract class Animal {
    public abstract void eat();

}

public class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

public class AnimalOperate {
    public void useAnimal(Animal a){//Aniaml a=new Cat();
        a.eat();
    }

    public Animal getAnimal()
    {
        Animal a=new Cat();
        return a;
    }
}

public class AnimalDemo {
    public static void main(String[] args) {
        //创建操作类对象，并调用方法
        AnimalOperate ao=new AnimalOperate();
        Animal a=new Cat();
        ao.useAnimal(a);


        Animal a2 = ao.getAnimal();//new Cat()
        a2.eat();
    }
 }

1.3 接口名作为形参和返回值

内部类

1.1 内部类概述

public class Outer {
    private int num=10;
    
    public class Inner{
        public void show()
        {
            System.out.println(num);
        }
    }
    
    public void method(){
        Inner i=new Inner();
        i.show();
    }
}

1.2 成员内部类

public class Outer {
   
        public  int num = 10;
/*
      private class Inner
      {
        public void show(){
            System.out.println(num);
        }
      }
 */

        private class Inner {
            public void show() {
                System.out.println(num);
            }
        }

        public void method () {
            Inner i = new Inner();
            i.show();
        }

    }

public class InnerDemo {
    public static void main(String[] args) {
        //创建内部类对象，并调用方法。

        /*
           Outer.Inner oi=new Outer().new Outer.Inner();
           oi.show();
        */
        Outer o=new Outer();
        o.method();

    }
 }

一般内部类都是private形式，不能在外部测试类中直接调用。

我们一般都是通过本类的外部类的方法调用内部类，然后外部测试类在通过那个方法调用内部类。

1.3 局部内部类

1.4 匿名内部类

1.5 匿名内部类在开发中的使用

七月第二周 7.5-7.10

学习目标：

学习内容：

继承

1.1 继承概述

1.2 继承的好处和弊端

1.3 继承中变量的访问特点

1.4 super

1.5 继承中构造方法的访问特点

继承中成员方法的访问特点

1.7 super的内存图

1.8 方法重写

1.9 方法重写的注意事项

1.10 继承的注意事项

案例一：老师和学生

案例二：猫和狗

修饰符

1、包

2、导包

2.1 导包的概述和使用

3、修饰符

3.1 修饰符的分类

3.2 权限修饰符

3.3 状态修饰符

多态

1.1 多态概述

1.2 多态中成员访问特点

1.3 多态的好处和弊端

1.4 多态中的转型

抽象类与接口

1、抽象类

1.1 抽象类概述

1.2 抽象类的特点

1.3 抽象类的成员特点

案例：猫和狗

2、接口

2.1 接口概述

2.2 接口的特点

2.4 接口的成员特点

案例：猫和狗

2.5 类和接口的关系

2.6 抽象类和接口的区别

案例：运动员和教练

3、面向对象中的形参和返回值

1.1 类名作为形参和返回值

1.2 抽象类名作为形参和返回值

1.3 接口名作为形参和返回值

内部类

1.1 内部类概述

1.2 成员内部类

1.3 局部内部类

1.4 匿名内部类

1.5 匿名内部类在开发中的使用

详细介绍电流互感器功能区别3CT SR ZCT

最近热搜

历史搜索 清除历史记录

历史搜索清除历史记录