类内的6种成员，4种可以被权限修饰符修饰

构造方法、成员方法、内部类、成员变量

static关键字及类成员的访问

可被static修饰的有类变量、类方法、内部类、代码块

构造方法不可使用static修饰

例：

// 类变量
private static String classVar = "Parents默认类变量";
// 类方法
public static void setClassVar(String classVar) {
	Parents.classVar = classVar;
}
// 代码块
static {
	System.out.println(classVar);
	System.out.println("Parents类代码块");
}
// 内部类
public static class innerClass{
	
}
// 构造方法，报错
public static Parents(){
    
}

java中static不是表示静态

其他类访问类变量可以直接使用类名.类变量或对象.类变量来访问类变量

实例变量只能使用对象名.实例变量访问

例：

class Parents{
    // 实例变量
    private String instanceVar = "Parents默认实例变量";
    // 类变量
	private static String classVar = "Parents默认类变量";
	// 类方法
    public static String getClassVar() {
		return classVar;
	}
    // 实例方法
    public String getInstanceVar() {
		return instanceVar;
	}
}
Parents parents = new Parents();
// 类名.类方法
System.out.println(Parents.getClassVar());
// 对象.类方法
System.out.println(parents.getClassVar());
// 对象.实例方法
System.out.println(parents.getInstanceVar());

实例方法可直接访问实例变量或者类变量

类方法不能访问实例变量只能访问类变量（同一个类可不加类名限制）

例：

class Parents{
    // 实例变量
    private String instanceVar = "Parents默认实例变量";
    // 类变量
	private static String classVar = "Parents默认类变量";
	// 类方法
    public static String getClassVar() {
		// 类方法访问类变量，同一个类可不使用类名限定
        return classVar;
        // 类方法访问实例变量，报错！！！
        System.out.println(instanceVar);
	}
    // 实例方法
    public String getInstanceVar() {
		// 实例方法访问实例变量
       // return instanceVar;
        System.out.println(instanceVar);
        // 实例方法访问类变量
       // return classVar;	
        System.out.println(classVar);
	}
}

类变量/类方法存在于类中，实例变量/实例方法存在于类的对象内

static在本类的访问方式

本类的类方法可访问类变量

内部类对象的创建：外部类的对象.内部类类名 内部类对象名 = new 外部类的对象.内部类构造方法？？？

外部类.内部类类名 内部类对象名 = new 外部类.内部类构造方法

class Parents{
    // 实例变量
    private String instanceVar = "Parents默认实例变量";
    // 类变量
	private static String classVar = "Parents默认类变量";
	// 类方法
    public static String getClassVar() {
		return classVar;
	}
    // 实例方法
    public String getInstanceVar() {
		return instanceVar;
	}
	// 内部类
	public static class innerClass{
		innerClass(){
			System.out.println("内部类");
		}
	}
}
Parents parents = new Parents();
// 内部类对象的创建
Parents.InnerClass innerClass = new Parents.InnerClass();

static的作用

为了在某个类中限制某个成员（变量、方法、内部类）是独一份的，各个对象共性它们

以变量为例加static的区别：

1.访问方式不同

有static：类和对象都能访问

无static：只能对象访问

2.数据共享性不同

有：类和最小共性同一份

无：每个对象独有

this关键字

this的两种用法

1.this()代表本类的其他构造方法

只能在本类的构造方法中使用（相当于一个构造方法调用另一个构造方法）

必须在第一句，且只能调用一次

例：

public class Parents {
	private int num;
	private String instanceVar = "Parents默认实例变量";
	private static String classVar = "Parents默认类变量";
	
	// 一个参数的构造方法
	Parents(String instanceVar){
		setInstanceVar(instanceVar);
	}
	// 两个参数的构造方法
	Parents(String instanceVar,String classVar){
		// 构造方法使用this()调用其他的构造方法
		this(instanceVar);
		setClassVar(classVar);
	}
	// 三个参数的构造方法
	Parents(String instanceVar,String classVar,int num){
		// 构造方法使用this()调用其他的构造方法
		this(instanceVar,classVar);
		setNum(num);
	}
}

2.this代表当前类的当前对象

在本类中代表当前对象，可在本类的方法、构造方法中使用（类方法不可使用）

public class Parents {
	private int num;
	private String instanceVar = "Parents默认实例变量";
	private static String classVar = "Parents默认类变量";
	// 一个参数的构造方法
	Parents(String instanceVar，String classVar){
		setInstanceVar(instanceVar);
		// 构造方法中使用this初始化实例变量
		this.classVar = classVar;
	}
	public void setInstanceVar(String instanceVar) {.
		// 实例方法中使用this初始化实例变量
		this.instanceVar = instanceVar;
	}
}

super关键字的两大功能

1.super()代表本类的父类的构造方法

只能在本类的构造方法中使用（相当于子类构造方法调用父类的构造方法）

必须在第一句，且只能调用一次

无论有无显式调用父类的构造方法在创建子类对象时系统都会自动调用父类的构造方法

如果没有显式调用父类的构造方法在子类的构造方法中会自动调用父类的无参构造方法，若父类无无参构造方法时子类必须显式调用父类的有参构造方法

public class Parents {
	private int num;
	private String instanceVar = "Parents默认实例变量";
	private static String classVar = "Parents默认类变量";
	// 无参构造方法
	Parents(){
		System.out.println("Parents()无参构造");
		setInstanceVar("Parents实例变量");
		setClassVar("Parents类变量");
	}
    // 一个参数的构造方法
	Parents(String instanceVar，String classVar){
		setInstanceVar(instanceVar);
		// 构造方法中使用this初始化实例变量
		this.classVar = classVar;
	}
	public void setInstanceVar(String instanceVar) {.
		// 实例方法中使用this初始化实例变量
		this.instanceVar = instanceVar;
	}
}
public class Son extends Parents {
	private int num;
	private String instanceVar = "Son默认实例变量";
	private static String classVar = "Son默认类变量";
	
	// 无参构造方法
	Son(){
        // 显式调用父类的无参构造方法
		super();
	}
	Son(String instanceVar，String classVar){
        // 显式调用父类的有参构造方法
		super(instanceVar,classVa);
	}
}

2.super在本类中代表当前类的父类对象

可以在本类的实例方法、构造方法中调用

对象的构建顺序（单个类）

1.构建static成员变量

2.执行static代码块（按顺序执行）类第一次被加载时执行，之后不再执行

3.构建实例成员变量（按顺序执行）每创建一个对象就执行一次

4.执行普通代码块

5.执行构造方法

例：

public class Parents {
	private int num;
	private String instanceVar = "Parents默认实例变量";
	private static String classVar = "Parents默认类变量";
	
	// 无参构造方法
	Parents(){
		System.out.println("Parents()无参构造");
		setInstanceVar("Parents实例变量");
		setClassVar("Parents类变量");
	}
	{
		// 实例代码块
		System.out.println(instanceVar);
		System.out.println("Parents实例代码块");
	}
	
	static {
		// 类代码块
		System.out.println(classVar);
		System.out.println("Parents类代码块");
	}
	// 类方法
	public static void setClassVar(String classVar) {
		Parents.classVar = classVar;
	}
	// 实例方法
	public void setInstanceVar(String instanceVar) {
		this.instanceVar = instanceVar;
	}
}
public static void main(String[] args) {
	Parents p = new Parents();
}
/*输出结果如下：
	 * Parents默认类变量
	 * Parents类代码块
	 * Parents默认实例变量
	 * Parents实例代码块
	 * Parents()无参构造
 */

有继承时：

1.构建父类static成员变量

2.执行static代码块（按顺序执行）类第一次被加载时执行，之后不再执行

3.构建子类static成员变量

4.执行子类static代码块（按顺序执行）类第一次被加载时执行，之后不再执行

5.构建父类实例成员变量（按顺序执行）每创建一个对象就执行一次

6.执行父类普通代码块

7.执行父类构造方法

8.构建子类实例成员变量（按顺序执行）每创建一个对象就执行一次

9.执行子类普通代码块

10.执行子类构造方法

例：

public class Parents {
	private int num;
	private String instanceVar = "Parents默认实例变量";
	private static String classVar = "Parents默认类变量";
	
	// 无参构造方法
	Parents(){
		System.out.println("Parents()无参构造");
		setInstanceVar("Parents实例变量");
		setClassVar("Parents类变量");
	}
	{
		// 实例代码块
		System.out.println(instanceVar);
		System.out.println("Parents实例代码块");
	}
	
	static {
		// 类代码块
		System.out.println(classVar);
		System.out.println("Parents类代码块");
	}
	// 类方法
	public static void setClassVar(String classVar) {
		Parents.classVar = classVar;
	}
	// 实例方法
	public void setInstanceVar(String instanceVar) {
		this.instanceVar = instanceVar;
	}
}
public class Son extends Parents {
	private int num;
	private String instanceVar = "Son默认实例变量";
	private static String classVar = "Son默认类变量";
	
	// 无参构造方法
	Son(){
		System.out.println("Son()无参构造");
		setInstanceVar("Son实例变量");
		setClassVar("Son类变量");
	}{
		// 实例代码块
		System.out.println(instanceVar);
		System.out.println("Son实例代码块");
	}
	
	static {
		// 类代码块
		System.out.println(classVar);
		System.out.println("Son类代码块");
	}
	// 类方法
	public static void setClassVar(String classVar) {
		Parents.classVar = classVar;
	}
	// 实例方法
	public void setInstanceVar(String instanceVar) {
		this.instanceVar = instanceVar;
	}
}
public static void main(String[] args) {
	Son son = new Son();
}
/*输出结果如下：
	 * Parents默认类变量
	 * Parents类代码块
	 * Son默认类变量
	 * Son类代码块
	 * Son默认实例变量
	 * Parents实例代码块
	 * Parents默认实例变量
	 * Parents()无参构造
	 * Son实例代码块
	 * Son默认实例变量
	 * Son()无参构造
 */

代码块的作用：初始化

static可用来修饰类变量，保持类的所有对象只初始化一次

问题

这里书写今日所遇到问题及解决方法 不要忽略小问题，小问题也要记下来。( 勿以善小而不为 )

吐槽

这里是吐槽部分，内容不限。