Java随记

静态代码块

// 在类第一次创建的时候使用且仅使用一次
//静态代码块优先于构造函数
static {
	/*代码块内容*/
}

继承

继承变量区分

局部变量：直接写
子类变量：this
父类变量：super
父类构造函数只能被子类构造函数使用，且只能使用一个，且必须在子类构造函数第一行
成员变量不能覆盖重写（只有方法可以）

继承关键字

类继承：extends（单继承）
接口继承：implements（多继承）
接口继承接口：extends

继承抽象函数的实现

若未实现父类（接口）全部抽象方法，子类也应当为抽象类

覆盖重写

覆盖函数子类返回类型【（类的继承）小于等于】父类返回类型
覆盖函数子类访问权限【大于等于】父类访问权限

@Override//检测是否覆盖
public 	String GetSth(){
	return null;
}

接口

Java 7：常量、抽象方法

public interface A{
	public static final int NUM_OF_A = 10;//public static final任意
	//static final int NUM_OF_A = 10;
	//final int NUM_OF_A = 10;
	//int NUM_OF_A = 10;
	//final修饰常量
	
	public abstract void FunctionA();//public abstract任意
	//public void FunctionA();
	//abstract void FunctionA();
	//void FunctionA();
}

Java 8：新增默认方法、静态方法

public interface A{	
	public default void FunctionB(){
	//可省略public
	//解决接口升级问题
	//添加默认方法后子类可直接使用，无需修改子类
	//子类也可覆盖重写默认方法
	}
	
	public static void FunctionC(){
	//可省略public
	//无法通过子类对象调用，通过接口名调用
	}
}

Java 9：新增私有方法

public interface A{
	private void FunctionA(){
	//private不可省略
	//解决接口中代码复用问题
	}	
}

接口无静态代码块、构造方法
多继承接口时重复的方法只覆盖重写一个即可
多继承接口时重复的默认方法，实现类必须覆盖重写
若父类和接口的方法冲突，优先使用父类方法
接口多继承（extends）接口，出现默认方法冲突，需覆盖重写（同样包含default）

多态

//Java
public class B{
	public int num=10;
	public void Show(){}
}

public class A extends B{
	public int num=20;
	public void Show(){}
}

B b = new A();
b.Show();//调用子类A的Show()
int n = b.num;//使用父类B的num

//C#
public class B
{
	public int num=10;
	public void Show(){}
}

public class A:B
{
	public int num=20;
	public void Show(){}
}

B b = new A();
b.Show();//调用父类B的Show()
int n = b.num;//使用父类B的num

类向下转型

if(Person instanceof Student){
	//instanceof返回bool值
}

final关键字

//修饰类
public final class A{
	//该类不能被继承，但是可以继承于其他类
}

//修饰方法
public class A{
	public final void Show(){
	//该方法不能被覆盖重写
	//final不能月abstract同时使用（意义矛盾）
	}
}

//修饰局部变量
final int n;
n = 10;//仅能赋值一次
final A = new A();//A指向的地址不能变，但该地址指向的类的内容可以变

//修饰成员变量
public class A{
	private final int num = 10;//直接赋值或者构造函数赋值，二选其一,仅能赋值一次
	
	public A(){
	//num = 10;
	}
}

权限修饰符访问

	public	protected	default（不写）	private
同一个类	Y	Y	Y	Y
同一个包不同类	Y	Y	Y	N
不同包子类	Y	Y	N	N
不同包非子类	Y	N	N	N

内部类

public class A{
	int num = 10;
	public class B{
		//内部类
		int num = 20;
		public void Show(){
		int num = 30;
		int n1 = num;//30
		int n2 = this.num;//20
		int n3 = A.this.num;//10
		}
	}
}

A.B ab = new A().new b();//定义对象

泛型

//泛型类
public class A<E>{
	//E只是个代表泛型的变量
}

//泛型方法
public <T> void Show(){
	//T只是个代表泛型的变量
}

//泛型接口
public interface B<E>{
	//E只是个代表泛型的变量
}

//泛型通配符：？
//只能用于接收不确定的类型,不能用于创建
//？ extends E：只能使用E类的子类或E类本身
//？ super E：只能使用E类的父类或E类本身

Socket

服务器端（ServerSocket）无法创建IO流，使用客户端的IO流