java面向对象下_1 （day09）

 static关键字的使用

          我们有时候希望无论是否产生了对象或者无论产生了多少对象的情况下，某些特定的数据在内存中只有一份，例如所有的中国人都有个国家名称，每一个中国人都共享这个国家名称，不必在每一个中国人的实例对象中都单独的分配一个用于代表国家名称的变量。

static 修饰属性

 

 

 static 修饰方法

   开发中要不要static:

 *     不会随着对象的不同而不同
 *     操作静态属性的方法同常为静态方法
 *     工具类的方法习惯上声明为static的。比如：Math  Arrays  Collections
 *     常量也一般使用static

设计模式与单例模式

 

package com.atfqs.java;
/*
 * 单例设计模式
 * 饿汉式 vs 懒汉式
 * 饿汉式：坏处 对象加载过长   好处：线程安全
 * 懒汉式：好处 延迟对象的创建，需要则创建 目前写法：线程不安全---->到多线程的时候修改
 */
public class SingletonTest1 {
	public static void main(String[] args) {
		Bank bank1 = Bank.getInstance();
		Bank bank2 = Bank.getInstance();
		System.out.println(bank1 == bank2);//true
		
		Order o1 = Order.getInstance();
		Order o2 = Order.getInstance();
		System.out.println(o1 == o2);//true
	}

}
//饿汉式
class Bank{
	//1 私有化类的构造器
	private Bank(){
		//避免用new造多个对象
	}
	//2 内部创建类的对象
	private static Bank instance = new Bank();
	
	//3 提供公共的方法 ，返回类的对象
	public static Bank getInstance(){
		return instance;
	}
}
//懒汉式
class Order{
	//1 私有化类的构造器
	private Order(){
		//避免用new造多个对象
	}
	//2声明当前对象，没有初始化
	private static Order instance = null;
	//3 提供公共的方法 ，返回类的对象
	public static Order getInstance(){
		if(instance == null){
			instance = new Order();
		}
		return instance;
	}
}

         eg：java.lang.runtime  //饿汉式

应用场景

 main方法的了解

 

 main方法与控制台交互的方法

一：在eclipse

/*
 * args的使用，可以作为与控制台的交互
 */
public class MainDemo {
	public static void main(String[] args) {
		for(int i = 0;i < args.length;i++){
			System.out.println("*******"+args[i]);
			int num = Integer.parseInt(args[i]);
			System.out.println("#######"+args[i]);
		}
	}
}

右键-->run as--->run Congfiguration

 

 

 二;在控制台

 代码块

package com.atfqs.java;
/*
 * 类的成员：代码块的使用（初始化块）
 * {   
 *   初始化类 对象
 * }
 * 代码块被修饰的时候只能使用static
 * 静态代码块   vs  非静态代码块
 * 1内部可以有输出语句
 * 2静态代码（可定义多个，谁在前先执行谁都早于非静态代码块）   
 *      块会随着类的加载而加载        而且只会加载这一次 初始化类的信息
 * 3非静态代码（可定义多个，谁在前先执行谁）
 *      块会随着new 对象而执行   每创建一个对象就执行一次非静态代码块 初始化对象的信息 
 */
public class BlockTest {
	public static void main(String[] args) {
		String desc = Person.desc;
		Person  p1 = new Person();
		System.out.println(p1.toString()+Person.desc);
		Person  p2 = new Person();
		System.out.println(p2.toString()+Person.desc);
	}

}
class Person{
	String name;
	int age;
	static String desc = "i am people";
	public Person(){
		
	}
	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	//静态代码块
	static{
		desc = "进入静态代码块，我修改了静态变量desc的值";
		System.out.println("静态代码块1\n"+desc);
	}
	static{
		System.out.println("静态代码块2\n");
	}
	//非静态代码块
	{
		name = "Jack";
		age = 12;
		System.out.println("非静态代码块");
	}
	public void eat(){
		System.out.println("eat!");
	}
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}
	public static void play(){
		System.out.println("public static void play()");
	}
}

               显式赋值与代码块的优先级相同，谁在前面先执行谁，

   执行顺序           代码块早于构造器  （由父及子，静态先行）

                            静态代码块早于非静态代码块早于构造器

final的使用

package com.atfqs.java;
/*
 * final的使用 （最终的）
 * final修饰的结构：类 方法 变量
 * final修饰类 不能有子类（最终的类）String System StringBuffer类  final class A
 * final修饰方法 （最终的方法）不能被子类重写 Object类中的getClass(); public fianl void show(){}
 * final修饰变量   (最终的变量) 不可改变 称为常量  final int a;
 *        final赋值的位置：显式初始化  非静态代码块赋值  构造器赋值 
 * static final：修饰属性 --->全局常量
 */
public class FinalTest {
	final int W = 1;
//	public void setW(){//The final field FinalTest.w cannot be assigned
//		w = 2;
//	}
//	public void show(final B b){
//		b.age = 12;
//		b.show();
//		System.out.println(b.toString());
//	}
	public static void main(String[] args) {
//		final int NUM = 10;
		FinalTest test = new FinalTest();
		test.show(new B());
	}

}
final class A{
	
}
//class B extends A{//The type B cannot subclass the final class A
//	
//}
class B{
	int age = 2;
	public final void show(){
		System.out.println("B");
	}
	@Override
	public String toString() {
		return "B [age=" + age + "]";
	}
}
//class C extends B{//Cannot override the final method 
//	public void show(){
//		
//	}
//}