java 定时器qz xm配置_java成神之——接口,泛型,类

接口

接口定义

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 test(T t);

}

MyInterface test = (t) -> t;

test.test("啦啦啦");

泛型

泛型类

class Test {

private T value;

public T getValue() {

return value;

}

public void setValue(T value) {

this.value = value;

}

}

Test test = new Test();

泛型类继承

第一种

class Inheritor extends Test {

}

Inheritor inherit = new Inheritor();

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

第二种

class Inheritor extends Test {

}

Inheritor inherit = new Inheritor<>();

inherit.setValue(1);

第三种

class Inheritor extends Test {

}

Inheritor inherit = new Inheritor();

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

第四种

class Inheritor extends Test {

}

Inheritor inherit = new Inheritor<>();

inherit.setValue(1);

第五种

抽象类

abstract class Test {

private T value;

public T getValue() {

return value;

}

public void setValue(T value) {

this.value = value;

}

}

Test test = new Test(){};

test.setValue("字符串");

类型限定

? extends T 表示?必须继承自T

? super T 表示?必须是T的父级

class Test{}

class Test>{}

泛型方法

public List Fn(T t1, T t2) {

List result = new ArrayList();

result.add(t1);

result.add(t2);

return result;

}

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

如果需要你可以强制指定自己需要的类型

List list = this.Fn(1, "a");

泛型接口

interface MyInterface {

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成神的系列文章之一

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

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