java成神之——接口,泛型,类

• 接口
  • 接口定义
  • 默认方法
  • 函数式接口
• 泛型
  • 泛型类
  • 泛型类继承
  • 类型限定
  • 泛型方法
  • 泛型接口
• 类
  • 构造函数
  • 类的继承
  • 抽象类
  • instanceof运算符
  • 内部类
  • equals
  • 结语

接口

接口定义

java中的接口也是单独使用一个文件定义，接口的定义相当简单，权限固定为public，变量只能定义为常量，方法只能抽象
        
接口成员只能是如下几种情况
    public interface MyInterface {
        public abstract void fn(); // 只能使用public修饰符
        abstract void fn1(); // 效果和上面写法一致
        public static final int a = 1; // 表示静态常量
        String b = "bb"; // 效果和上面写法一致
    }

默认方法

interface MyInterface {
    default void fn() {
        System.out.println( "default implementation" );
    }
}
public class Test implements MyInterface {

    @Override
    public void fn() {
        System.out.println( "overridden implementation" );
    }

    public static void main(String[] args) throws Exception{
        MyInterface.super.fn();
        fn();
    }
}

函数式接口

@FunctionalInterface
public interface MyInterface<T> {
	T test(T t);
}

MyInterface<String> test = (t) -> t;
test.test("啦啦啦");

泛型

泛型类

class Test<T> {
    private T value;
    public T getValue() {
        return value;
    }
    public void setValue(T value) {
        this.value = value;
    }
}
Test<Integer> test = new Test<Integer>();

泛型类继承

第一种

class Inheritor extends Test<String> {
}

Inheritor inherit = new Inheritor();
inherit.setValue("只能是字符串");

第二种

class Inheritor<T> extends Test<T> {
}

Inheritor<Integer> inherit = new Inheritor<>();
inherit.setValue(1);

第三种

class Inheritor extends Test {
}

Inheritor inherit = new Inheritor();
inherit.setValue("这里可以传递任何类型的值");

第四种

class Inheritor<T, E> extends Test<E> {
}

Inheritor<String, Integer> inherit = new Inheritor<>();
inherit.setValue(1);

第五种

抽象类
abstract class Test<T> {
    private T value;
    public T getValue() {
        return value;
    }
    public void setValue(T value) {
        this.value = value;
    }
}

Test<String> test = new Test<String>(){};
test.setValue("字符串");

类型限定

? extends T         表示?必须继承自T
? super T           表示?必须是T的父级

class Test<T extends Object>{}
class Test<T extends Object & Iterable<T>>{}

泛型方法

public <T> List<T> Fn(T t1, T t2) {
    List<T> result = new ArrayList<T>();
    result.add(t1);
    result.add(t2);
    return result;
}

List<String> list = Fn("a", "b"); // 无需手动指定泛型类型，程序会自动推断类型

如果需要你可以强制指定自己需要的类型
List<Object> list = this.<Object>Fn(1, "a");

泛型接口

interface MyInterface<T> {
    public void Fn(T t);
}

类

构造函数

单个构造函数
    public class demo2 {
        public int a;
        public demo2 (int i) {
            this.a = i;
        }
    }
        
多个构造函数
    public class demo2 {
        public int a;
        public demo2() {
            this(111); // 只能写在第一行
        }
        public demo2 (int i) {
            this.a = i;
        }
    }

类的继承

    public class Test2 {
        public String str = "aaa";
    }

    public class Test1 extends Test2 {
        public void fn() {
            System.out.println(str);
        }
    }

    java中子类重写父类的方法，直接写方法就可以了，
    子类中的重写的方法的权限必须大于或者等于父类方法的权限

    子类继承父类，需要父类有无参数的构造函数
    
    默认情况下，类不写构造函数会自动编译一个无参数构造函数，除非人为指定构造函数，如下
            
    public class demo2 {
        public demo2(int i) {
        }
    }
            
    public class demo1 extends demo2 {
        public int a;
        public demo1() {
            // super(); 默认情况下不写super，系统会自动编译成 super()，所以父类不包含无参数构造函数就会报错
            super(111); // super只能写在第一行
        }
    }

抽象类

    抽象类，就是一个风马牛不相及的东西的共性提取，不能实例化
    abstract public class Test3 {
        public String str = "aaa";
        public abstract void fn(); // 抽象方法只能定义，具体实现必须在子类中完成
    }
    抽象方法不能和 private,final,static 一起使用

instanceof运算符

    用来判断一个对象是否是一个类的实例
    demo2 test = new demo2();
	boolean b = test instanceof demo2;

内部类

    public class demo {
        int i = 1;
        public class demo1 {
            int i = 2;
            public void fn() {
                int i = 3;
                System.out.println(i); // 3
                System.out.println(this.i); // 2
                System.out.println(demo.this.i); // 1
            }
        }
    }
    使用此内部类
    demo.demo1 test1 = new demo().new demo1();
    test1.fn();

equals

    引用类型比较的地址是否相同，值类型比较值是否相同
        demo test1 = new demo();
        demo test2 = new demo();
        boolean b = test1.equals(test2);
    可以重写equals方法，实现自定义比较
        public boolean equals (Object obj) {
            demo d = (demo)obj;
            return this.a = d.a;
        }

结语

本文章是java成神的系列文章之一

如果你想知道，但是本文没有的，请下方留言

我会第一时间总结出来并发布填充到本文