接口
接口定义
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成神的系列文章之一
如果你想知道，但是本文没有的，请下方留言
我会第一时间总结出来并发布填充到本文