this，static关键字，block，GC

• 一、this关键字

 *     1.在构造的首行调用其他构造器 
 *         this([参数列表]);        
 *     2.区分同名变量|形参|属性,this指代当前对象
      
 *     注意:
 *       1.想要使用this调用其他构造器必须在构造器的首行
 *       2.调用其他构造器的时候不能相互调用
 *       3.this在没有同名参数或者局部变量的时候可以省略,如果有同名问题,想要执行对象中的属性时,必须使用this,否则就是就近原则
 *       4.this不能使用在被static修饰的方法中,否则会报错
 *       5.普通方法中，this总是指向调用该方法的对象。构造方法中，this总是指向正要初始化的对象。

public class Computer02 {
	// 牌子
	String brand;
	// 价格
	double price;

	public Computer02() {
		this(9000);
		System.out.println("我是空构造...");
	}

	// 带参
	public Computer02(double price) {
		// this("外星人",20000);
		// this.price=price;
		this("外星人", price);
		System.out.println("我是带参构造...");
	}

	public Computer02(String brand, double price) {
		// this();
		if (price < 10000) {
			price = 10000;
		}
		this.price = price;
		this.brand = brand;
		System.out.println("我是带参构造2...");
	}

	// play
	public void play() {
		int price = 5;
		System.out.println(this.brand + "牌子的电脑的价格是" + this.price + "   , "
				+ price);
	}
}

 

• 二、static关键字

 *     1.static修饰变量 (只能修饰成员变量,不能修饰局部变量)
 *         是属于类的,在类加载的时候只初始化一次
 *     2.static修饰方法--静态方法
 *         static修饰的内容使用方式:
 *                      1.类名.变量名;
 *                         类名.方法名();
 *                      2.数据类型  变量=new 数据类型();
 *                          引用.变量名;
 *                          引用.方法名();
 *                      如果在当前类中,类名可以省略
 * 
 *      静态的是属于类的,成员是属于对象的
 *     1.静态的内容中只能直接使用静态的内容,不能直接使用非静态的内容
 *     2.非静态的内容中,可以直接使用静态的内容,也可以直接使用非静态的内容
 *     3.静态的变量是只有一份的

public class StaticDemo06 {
	// static修饰成员变量
	static int id = 5;
	int age = 18;

	public static void main(String[] args) {
		// int id=10;
		// static int a=5;
		// 类名.
		System.out.println(id);
		System.out.println(StaticDemo06.id);
		StaticDemo06 staticDemo06 = new StaticDemo06();
		// 对象.
		System.out.println(staticDemo06.id);
		System.out.println(staticDemo06.age);

		System.out.println("---------------1----------------");
		change();
		System.out.println(StaticDemo06.id); // 6
		System.out.println(staticDemo06.age); // 18
		System.out.println("----------------2---------------");
		change();
		System.out.println(staticDemo06.id); // 7
		System.out.println(staticDemo06.age); // 18

		staticDemo06.test();
		System.out.println(staticDemo06.id); // 8
		System.out.println(staticDemo06.age); // 19
	}

	/*
	 * 静态方法: 改变id和age的值
	 */
	public static void change() {
		id++;
		StaticDemo06 staticDemo06 = new StaticDemo06();
		staticDemo06.age++;
		System.out.println("change()------" + id + "-->" + staticDemo06.age); // 7
																				// 19
	}

	// 成员方法
	public void test() {
		id++;
		age++;
		System.out.println(id + "-->" + age); // 8 19
	}
}

 

• 三、block

 *     1.在方法中{ }    普通语句块                    执行时机:调用方法时候
 *     2.用类中方法外{ }    构造块                执行时机:创建对象时候
 *     3.用在类中方法外 static{ }    静态块        执行时机:加载类的时候
 *  
 *  注意:
 *      1.构造块先于构造器执行,每创建一个对象,都会执行一个构造块,当有多个构造块时,是从上到下一次执行
 *      2.静态块在类加载的时候只加载一次,先于主方法执行,当有多个静态块时,是从上到下一次执行

 *      静态代码块：在java中使用static关键字声明的代码块
 *      静态代码块用于初始化类，为类的属性初始化。每个静态代码块只会执行一次
 *      由于JVM在加载类时会执行静态代码块，所以静态代码块先于主方法执行
 *      若类中包含多个静态代码块，按照"先定义的先执行"
 * 注意：静态代码不能存在于任何方法体内
 *     静态代码块不能直接访问静态实例变量和实例方法，需要通过类的实例对象来访问
 *     静态代码块====>main方法=====>构造代码块===>构造方法

 *     构造块就是构造器的一部分,先于构造器中的内容执行,但是,如果有调用其他构造器的this(),会先执行

public class BlockDemo08 {
	static int a=8;
	double d=1.1;
	
	//空构造
	public BlockDemo08() {
		System.out.println("我是空构造...");
	}
	
	//构造块
	{
		System.out.println(a);
		System.out.println(d);
		a++;
		this.d++;
	}
	{
		System.out.println(a);
		System.out.println(d);
	}
	
	//静态块
	static{
		System.out.println("我是静态块1");
	}
	static{
		System.out.println("我是静态块2");
	}
	static{
		System.out.println("我是静态块3");
	}
	
	public static void main(String[] args) {
		System.out.println("main");
		int a=10;
		//普通语句块
		{
			a=5;
			//System.out.println(a);  //5
		}
		//System.out.println(a);  //5
		
		//创建对象
		BlockDemo08 bd1=new BlockDemo08();
		BlockDemo08 bd2=new BlockDemo08();
	}
}

 

• 四、GC

 *   垃圾回收机制
 *     System.gc();通知系统回收垃圾(回收不回收,什么时候回收,你无法决定)
 *     在垃圾回收机制去回收垃圾的时候调用的第一个方法为finalize()方法
 *         一定会调用垃圾会调用finalize的两种情况:
 *                                         1.匿名对象
 *                                         2.对象无引用状态
 *  注意:如果系统能为我们做的事,一般我们都不手动进行操作
 *      注意面试

public class GCDemo10 {
	int a;
	int b;
	public static void main(String[] args) throws InterruptedException {
		//匿名对象
		new GCDemo10(1,2);
		System.gc();  //通知
		
		//对象无引用
		GCDemo10 s=new GCDemo10(1,2);
		System.gc();
		
		//思考:是否为对象无引用状态
		/*
		StaticDemo06 s1=new StaticDemo06(1,2);
		StaticDemo06 s2=s1;
		s1=null;
		System.gc();
		*/
		
		//睡眠 10s  --看效果
		Thread.sleep(10000);
	}
	
	//带参构造
	public GCDemo10(int a,int b) {
		this.a=a;
		this.b=b;
	}
	
	@Override
	protected void finalize() throws Throwable {
		System.out.println("over...");
	}
	
	public void test(GCDemo10 s ){
		System.out.println(s.a+"-->"+s.b);
	}
}

 

• 五、package和import

package

 * package语句作为Java源文件的第一条语句
            * 注意:不要定义与jdk相同的包，相同的类，  否则会引起很多你觉得莫名其妙的问题

import

 * 不需要使用import的类有
                1、语言包 （java.lang）下的类
                2、同包下的类

    静态导入
    
            模糊匹配 *的缺点:
                   拖慢加载速度,不是运行速度.

JDK中常用的包简单介绍：

①java.lang –语言包 ：语言中常用的功能 语言中常用的功能 语言中常用的功能 ，如 String、Math、 System、Integer、Thread…

②java.util – 工具包 ：提供一些实用的工具类 提供一些实用的工具类 提供一些实用的工具类 提供一些实用的工具类 ，如 容器 （List、 Set、Map…）,日期类 日期类

③java.io – 输入出包 输入出包 ：提供操作读取文件的相关类 提供操作读取文件的相关类 提供操作读取文件的相关类 提供操作读取文件的相关类 提供操作读取文件的相关类 ，如 File、 InputStream、OutputStrem…

④ java.net – 网络包 ： 操作远程资源的类 操作远程资源的类 操作远程资源的类 操作远程资源的类 操作远程资源的类 操作远程资源的类 操作远程资源的类 操作远程资源的类 ， 如 InetSocketAddress、 DatagramPacket 、ServerSocket…

⑤java.sql – 数据库包 ：操作 JDBC的类 ，Connection、Statement、 ResultSet….