    public class Animal {
        String name="小动物";
        public void eat() {
            System.out.println(name + "吃东西");
        }

        public void sleep() {
            System.out.println(name + "在睡觉");
        }

    }

再定义个Dog类

public class Dog extends Animal {
    public Dog() {

    }
    void bark() {
        System.out.println(name + "旺旺~");//name继承Anima类
    }
}

在Test类测试输出

public class Test {

    public static void main(String[] args) {
        Dog dog = new Dog();
        System.out.println(dog.name);
        dog.eat();
        dog.sleep();
        dog.bark();
    }

}

结果：

如果Dog类里也有变量name，方法eat

public class Dog extends Animal {

    String name="狗";
    void bark() {
        System.out.println(name + "旺旺~");
    }
    @Override
    public void eat() {
        System.out.println("狗吃东西");
    }
}

结果：

会发现子类访问父类时，先看本类里有没有，然后再去父类里找.

如果子类与父类方法的参数列表不同则构成重载，根据方法调用的参数列表选择合适的方法

6.3super

如果我就想调用父类方法怎么办？Super就提供了这个功能

public class Dog extends Animal {

//    String name="狗";
    void bark() {
        System.out.println(name + "旺旺~");
    }
    @Override
    public void eat() {
        System.out.println("狗吃东西");
        super.eat();//在子类调用父类的eat方法
    }
}

Test类

public class Test {

    public static void main(String[] args) {
        Dog dog = new Dog();
        System.out.println(dog.name);
        dog.sleep();
        dog.bark();
        dog.eat();
    }

}

结果：

6.4super与this的区别

6.5 父类访问子类

有的人想用父类访问子类，但是这样做继承的意义何在？虽然可以但不推荐。

7.权限修饰符

8.static

8.1概念

8.2static的访问特点

9.final

9.1概念

9.2final修饰局部变量

二.多态

1.多态的概念

同一个对象，在不同的时刻表现的不同形态

举例：猫

我们可以说：猫 cat=new 猫();

也可以说：动物 animal =new 猫();

多态的前提与体现：

有继承/实现关系
有方法重写
有父类引用指向子类对象

2.多态成员的访问特点

成员变量：编译看左边，执行看左边
成员方法：编译看左边，执行看右边

举例：

定义Anima类

package animal;

    public class Animal {
        String name="小动物";
        public void eat() {
            System.out.println(name + "吃东西");
        }

        public void sleep() {
            System.out.println(name + "在睡觉");
        }

    }

定义Dog类

package animal;

public class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("狗吃东西");
    }
}

定义Cat类

package animal;

public class Cat extends Animal {

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

在Test类进行测试

package animal;

public class Test {

    public static void main(String[] args) {
        Animal dog = new Dog();
        Animal cat =new Cat();
        cat.eat();
        dog.eat();


    }
}

结果

如果我向Dog类添加变量num，并将权限改到最大

 public int num=10;

结果爆红：

这就牵扯到了多态的转型

3.多态的转型

3.1向上转型

格式：父类名变量名=new 子类名();

由下向上是自动的

本质:父类的引用指向子类的对象

不能调用子类的特有成员

3.2向下转型

本质：父类引用转为子类引用

格式：子类名变量名=(子类名)父类名;

不能强制转换父类的对象，只能转引用
必须指定子类类型
可以调用子类类型所有成员

3.3多态的好处和弊端

三.抽象类

1.概念

Java中一个没有方法体的方法应该定义为抽象方法，而类中有抽象方法就必须定义为抽象类

2.抽象类的特点

3.抽象类成员的特点

4.抽象类的使用

看看抽象类在多态的使用

先定义抽象类Animal

    abstract public class Animal {
        String name="小动物";
        abstract void eat() ;//抽象方法不能有方法主体

        public void sleep() {
            System.out.println(name + "在睡觉");
        }

    }

子类Dog继承Animal

public class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("狗吃东西");
    }
}

如果不重写就报错

这时候就体现了抽象类的好处了，如果你想要重写父类的一个方法但忘了，系统就会提醒你。

四.接口

1.概念

在Java中接口更多体现在对行为的抽象

2.接口特点

3. 接口成员特点

成员方法只能是抽象方法，我们也可以理解它是一个抽象类。里面全是全局变量和抽象方法组成。

4.接口的使用

说白了，如果使用接口，那么就必须把里面的抽象方法全部重写一遍，接口才会承认你，或者你自己是抽象类

举例

定义接口Animal

public interface Animal {
      int a=1;//默认是被final修饰的，这里就不需要加了
    public abstract void eat();
    public abstract void sleep();

}

定义接口实现类Dog

public class Dog implements Animal{
    @Override
    public void eat() {
        System.out.printf("狗在吃东西");
    }
    @Override
    public void sleep(){
        System.out.printf("狗在睡觉");
    }
}

在Test类里进行测试

public class Test {
    public static void main(String[] args) {
        Dog dog=new Dog();
        dog.eat();
        dog.sleep();
        System.out.println(dog.a);
    }
}

结果

4.抽象类与接口的区别

五.内部类

你是否想过一个类里面能不能再定义个类，这当然可以，它有个名字叫做内部类

1.内部类的概念

在A类里定义B类，B类就叫做内部类

2.内部类格式

public class 类名{
修饰符 class 类名{



} 
}

3.内部类的访问特点

内部类可以直接访问外部类的成员，包括私有变量
外部类要想访问内部类必须创建对象

4.内部类的分类

在类的成员位置：成员内部类
在类的局部位置：局部内部类

5.成员内部类

成员内部类创建对象格式：外部类.内部类对象名 = 外部类对象.内部类对象

public class Test {
    
public class test2{//test2为成员内部类
    
public void inner(){
    System.out.println("我是成员内部类");
}

}

    public static void main(String[] args) {
        Test.test2 demo = new Test().new test2();

    }
}

6.局部内部类

局部内部类是定义在外部类的局部位置，比如方法中，并且有类名，外界无法直接使用，需要在方法内部创建对象并使用。但不能被修饰符修饰如public，但可以被final修饰。

public class Test {
    
    
public void A1(){
       class test2{//在方法里定义局部内部类
               public void inner(){
                       System.out.println("我是局部内部类");
               }
             }
       test2 demo =new test2();//在方法里创建局部内部类的对象
       demo.inner();//调用局部内部类的方法
}

    public static void main(String[] args) {
      Test demo1=new Test();//创建外部类对象
      demo1.A1();//调用方法，从而间接地调用局部内部类的方法
    }
}

结果