抽象类和接口

抽象类

什么是抽象类

被abstract修饰的类就是抽象类

抽象类不能进行实例化

在这里插入图片描述

继承了抽象类,需要重写里面的所有抽象方法,不重写会报错

在这里插入图片描述

public abstract class Person {
    public static void eat(){
        System.out.println("我饿了,想吃点好的");
    }
    public abstract void sleep(); 
}
public class Student extends Person{
    @Override
    public void sleep() {
    }
}

有抽象方法的就一定是抽象类

在这里插入图片描述

有final,private,static修饰的不能被重写

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

抽象类的出现就是为了被继承,多了一层编译器的校验

接口

想要让某个对象去拥有对应的行为就可以定义成接口

接口的应用

比如说,定义了运动员和教练的类,运动员和教练中都有会说英语的,那么说英语这个行为,可以由运动员和教练中的任意一个完成都行,所以就可以写成接口,只要实现了接口就是可以完成某种行为

interface关键字

通过interface关键字就可以去创建某个接口了

注意事项

  1. 接口中的成员变量默认是由public static final所修饰的
    在这里插入图片描述

  2. 接口里的抽象方法默认都是public abstract 所修饰的
    在这里插入图片描述 4. 如果接口中的方法被default 或者static 修饰可以有具体实现
    也就是接口中的默认方法和静态方法

public default

注意事项

默认方法不是抽象方法,所以不强制被重写,但是如果要重写,需要去掉default关键字

public可以省略,default不能省略

在这里插入图片描述

接口中的静态方法

格式:public static 返回值类型 方法名(参数列表){
}

注意事项

静态方法只能通过接口调用,不能实例化

public interface Inter {
	public static void swim(){}
	public static void play(){
   		swim();
	}
}

不能被重写(子类把从父类继承下来的虚方法表里的方法进行了覆盖才是重写),而静态方法是没有被被到虚添加方法表里的

4.接口比抽象类还抽象不可以进行实例化
在这里插入图片描述

5.作为父类对象还是可以引用对象的,也就是new子类的对象

public class Student extends Person implements Inter{
}
public class Test {
    public static void main(String[] args) {
       Person person=new Student();
       person.sleep();
    }
}

6.类和接口之间可以使用关键字implements实现接口
在这里插入图片描述

7.一个接口对应一个.class文件

8.如果一个类不想实现接口中的方法,可以使用抽象类
在这里插入图片描述
但是抽象类再被继承就得重写接口中的方法和抽象方法

总结

一个类可以实现多个接口,解决类只能单继承问题
对于接口可以用对象来接收实现了多态,同样需要重写方法,然后可以进行调用

Object类

是所有类默认的父类

内部类

局部内部类

方法里写一个内部类
相当于方法里得局部变量
很少这样写

实例内部类

如何是实例化成员内部类对象?
直接创建
格式:外部类类名.内部类名=外部类对象.内部类对象

public class Outer {
    String name;

    class Inner {
        static int a = 10;
    }
}
   Outer.Inner oi=new Outer().new Inner();

private修饰的方法
通过外部类编写方法,对外提供内部类方法

 public static void main(String[] args) {
      Outer o=new Outer();
      System.out.println(o.getInstance());
  }
public class Outer {
    String name;
    private class Inner{
        static int a=10;
    }
    public Inner getInstance(){
        return  new Inner();
        }
    }

访问同名成员变量

首先就近原则

如果要引用外部类的成员变量

就需要引用外部类引用.this.去引用

也可以外部名.this.去引用

静态内部类

在类里面再定义一个

语法是static class 类名{
里面可以有成员变量和成员方法
}

如何是实例化静态内部类对象?

只要是静态的,都可以直接用类名直接调用

实例化要把内部类和外部类看成整体Out.inner

匿名内部类(掌握)

理解:

隐藏了名字的内部类,可以写在成员位置,也可以写在局部位置

是new出来的对象,真正的匿名体是大括号

继承或实现关系

方法的重写

创建对象

调用方法:

new 外部类类名(){

重写方法

}.方法;

public abstract class Outer {
    public void eat(){
        System.out.println("哈哈");
    }
}

public class Inner extends Outer {
    public static void main(String[] args) {
        new Outer(){
            @Override
            public void eat() {
                System.out.println("嘿嘿");
            }
        }.eat();
    }
}

使用场景

作为方法参数,没有名字的类继承了Animal这个类
作为Animal的子类对象传递给method时就构成了多态

public abstract class Animal {
    abstract void eat();
}
public class Test1 {
    public static void main(String[] args) {
        method(
            new Animal() {

                @Override
                void eat() {
                    System.out.println("狗不爱吃骨头");
                }
            }
        );
    }
    public static void method(Animal a){//Animal a=子类对象——多态
        a.eat();
    }

}

总结

相信小伙伴看到这已经对抽象类和接口有了一定了解,一起加油啊在这里插入图片描述

评论 27
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值