JAVA基础知识复习（下半部分）

JAVA基础知识复习

三大修饰符

static

什么是静态？

引言

在对象创建后，实例属性，是各个对象持有的独立的空间（多份），对象单方面修改不会影响其他对象。
静态属性，是整个类持有的共享空间（一份），任何修改都会影响到其他对象。

概念

static 可以修饰方法和属性。
修饰方法则称为静态方法
修饰变量则称为静态属性
在全类中只有一份，不会因为创建多个对象而产生多份，不必创建对象，可直接通过类名访问。
在类加载时创建，不会重复创建。

静态属性

	public class TestStatic{
		static int b=1;
		public static void main(String[] args){
			System.out.println(b)
		}
	}

访问：类名.静态变量名。
	 例如TestStatic.b;

静态方法

		public class TestStatic{
		static int b=1;
		//main函数就是一个静态方法
		public static void main(String[] args){
			System.out.println(b)
		}
		
		//函数就是一个静态方法
		public static void method(String[] args){
			System.out.println(b)
		}
		
	}

访问：类名.静态方法名称。
	 例如TestStatic.method;

注意事项

静态方法允许直接访问静态变量 
静态方法不能直接访问非静态成员
静态方法中不允许出现this或者super关键字
静态方法可以继承没有多态。

动态代码块

		public class TestStatic{
		//直接标记的代码块，可以直接执行
		{
		
		}
		static int b=1;
		//main函数就是一个静态方法
		public static void main(String[] args){
			System.out.println(b)
		}
		
	}

位置：类内方法外，{}标记使用。
创建对象时，触发动态代码块的执行
执行地位:初始化属性之后，构造方法之前，

作用

可以为实例变量赋值，或者必要的初始化行为。

类加载

当JVM首次使用某个类时，需要通过calsspath查找该类的class文件
将class文件中对类的描述信息加载到内存中进行保存
比如：类名 父类属性 方法 构造方法...

加载时机

创建对象
创建子类对象
访问静态对象
调用静态方法。

静态代码块

		public class TestStatic{
		//直接标记的静态代码块，可以直接执行
		static {
		
		}
		static int b=1;
		//main函数就是一个静态方法
		public static void main(String[] args){
			System.out.println(b)
		}
		
	}

位置：类内，方法外，static{}标记触发，
类加载时，触发静态代码块的执行（仅一此）。

执行地位

静态属性初始化之后

作用

可为静态属性赋值或者必要的初始化行为。

理解静态与实例的关系

静态在类加载时完成创建，而实例则是在类加载完毕后，对象创建后。
在执行顺序上
父类静态属性（有就加载）
父类静态代码块（有就加载）
子类静态属性
子类静态代码块
---------------------（以下是实例时触发的）
父类实例属性（有就加载）
父类动态代码块（有就加载）
父类构造方法（有就加载）
子类实例属性
子类动态代码块
子类构造方法

abstract

什么是抽象？

具有某种对象的特征，但不完整
程序中用来模拟现实世界，解决现实问题的
现实世界中存在的都是“动物”，不应当创建出对象，只应该创建子类对象。

语法

	public abstract class TestAbstract{
	}
	class Test  extends TestAbstract{
	}

应用：abstract 修饰符，说明此类不可以被创建，无法使用new 关键字
被abstract修饰的类，被称为抽象类，表示这个类不是一个具体的类。
抽象类无法独立存在，因为不能new对象，必须要有具体子类，

抽象类的作用

可以被子类集成，提供共性属性和方法
可以声明为引用，强制使用多态
例如：TestAbstract ta=new Test（）;

抽象方法

abstract 修饰方法 
只有声明,没有方法的实现，意味着这是个不完整的方法，她只能在抽象类中，非抽象子类必须实现。

语法

	public abstract class TestAbstract{
		//这是个抽象方法
		public abstract eat();
	}
	class Test  extends TestAbstract{
		//子类必须实现抽象方法
		public void eat(){
			
		};
	}

注意

抽象类中不一定有抽象方法,但是抽象方法肯定在抽象类中.
抽象类继承另一个抽象类,不需要重写父类的抽象方法.

总结
abstract 修饰符可以修饰方法可以修饰类.
修饰类:此类变为抽象类,无法创建对象,但是可以作为声明.
修饰方法:只有方法声明,但是没有方法实现,

final

什么是最终?

最后的,不可更改的

使用范围

类 方法 变量
修饰类时称为最终类.
fianl 类
		此类无法被继承，例如System。
修饰方法时称为最终方法.
	修饰方法:此方法不能被覆盖，意味最终发那个发，不支持子类以覆盖的形式修改
修饰变量时称为最终变量.
	此变量的值无法被修改，称为常量。

	//此类无法被继承
	public final  class TestFinal{
	
		//常量没有默认值;
		final String name="name";
		
		//静态常量没有默认值,静态常量必须全部大写，如果存在字母拼接，则通过下划线分开（业内规范）
		static final String CLASS_PATH="classpath";
		//此方法可以被继承，但是无法重写
		public final void method(){
			final int a=1;
		}
	}

常量的赋值时机
	显示初始化
	动态代码块
	构造方法
静态常量的赋值时机
	显示初始化
	静态代码块

注意

final修饰基本类型常量时，值不可变，修饰引用类型常量时，地址不可变。

什么修饰符可以连用?

访问权限修饰符（private protected default public）可以与static final 连用。
访问权限修饰符（protected default public）可以与abstract 连用。
static 与final 可以连用，最好加上public 构成公开静态常量。

接口

接口的概念

宏观：是一种标准，接口的实现者和使用者都必须遵守的约定
从语法角度来说，接口相当于一个特殊的抽象类

语法
关键字interface

没有构造方法，不能单独创建对象，但是可以声明引用；
所有属性都是公开的静态常量，被默认为public static final修饰；
所有方法都是公开的抽象方法,被默认 public abstract 修饰；

public interface TestInterface(){
	//所有方法都是公开的抽象方法
	add();
	
	//所有的变量都是公开静态常量
 	int a;
}

抽象类与接口的异同

相同点
	可编译
	不可以创建对象
	都可以声明，但不能创建对象
不同
	接口只能有公开静态常量以及公开抽象方法。没有构造方法

如何实现接口？
关键字implements

public interface TestInterface(){
	//所有方法都是公开的抽象方法
	void add();
	
	//所有的变量都是公开静态常量
 	int a;
}

public class TestImpl implements TestInterface{
	public void add(){
		
	}
}

注意

一个类实现了接口,如果不想称为抽象类,必须实现接口中的所有的抽象方法.
实现类实现接口中的方法时,方法的访问修饰符必须是public   

内部类

概念:在一个类的内部再定义一个完整的类(了解)
例如

public class TestInClass {
    class InClass{
        
    }
}

编译时,出现两个class 字节码文件
特点
编译之后生成独立的字节码文件.
内部类可以直接访问外部类的私有成员,而不破坏封装
可为外部类提供必要的内部功能组件.