Java基础之对象的一对一关系 static关键字 代码块

两个对象之间的一对一关系：
比如：
一个英雄（Hero）对一个兵器（Weapon）

代码如何表示？

/**
	两个对象之间的一对一关系：
	比如：一个英雄（Hero）对一个兵器（Weapon）
	双向一对一
	单向一对一
*/
public class Test5{
	public static void main(String[] args){
		Hero hero = new Hero("刘备",300);
		Weapon weapon = new Weapon("双股剑",3);
		
		//把两个对象关联起来
		hero.setWeapon(weapon);
		weapon.setHero(hero);
		
		//通过英雄来获取他的信息
		String name = hero.getName();
		int age = hero.getAge();
		Weapon w = hero.getWeapon();
		System.out.println("我是"+name+"，我"+age+"岁，我的武器是："+w.getName()+",排行"+w.getGrade()+"级");
		
	}
}
//英雄类
class Hero{
	private String name;
	private int age;
	private Weapon weapon;//一对一关系
	public void setWeapon(Weapon weapon){
		this.weapon = weapon;
	}
	public Weapon getWeapon(){
		return weapon;
	}
	public Hero(){}
	public Hero(String name,int age){
		this.name = name;
		this.age = age;
	}
	public void setName(String name){
		this.name = name;
	}
	public String getName(){
		return name;
	}
	public void setAge(int age){
		this.age = age;
	}
	public int getAge(){
		return age;
	}
}
//兵器类
class Weapon{
	
	private String name;
	private int grade;
	private Hero hero;
	public void setHero(Hero hero){
		this.hero = hero;
	}
	public Hero getHero(){
		return hero;
	}
	
	public Weapon(){}
	public Weapon(String name,int grade){
		this.name = name;
		this.grade = grade;
	}
	public void setName(String name){
		this.name = name;
	}
	public String getName(){
		return name;
	}
	public void setGrade(int grade){
		this.grade = grade;
	}
	public int getGrade(){
		return grade;
	}
}

static关键字的作用：

1、使用static关键字修饰一个属性

声明为static的变量实质上就是全局变量 即生命周期变长了

2、使用static关键字修饰一个方法
通常，在一个类中定义一个方法为static，那就是说，无需本类的对象即可调用此方法

3、使用static关键字修饰一个类（内部类）

static 关键字

1、静态变量或方法不属于对象，依赖类
2、静态变量是全局变量，生命周期从类被加载后一直到程序结束
3、静态变量只有存一份，在静态方法区中存储
4、静态变量是本类所有对象共享一份
5、建议不要使用对象名去调用静态数据，直接使用类名调用
6、static修饰一个方法，那么该方法属于类，不属于对象，直接用类名调用
7、静态方法不能访问非静态属性和方法，只能访问静态。

/**
	static 关键字
	1、静态变量或方法不属于对象，依赖类
	2、静态变量是全局变量，生命周期从类被加载后一直到程序结束
	3、静态变量只有存一份，在静态方法区中存储
	4、静态变量是本类所有对象共享一份
	5、建议不要使用对象名去调用静态数据，直接使用类名调用
	6、static修饰一个方法，那么该方法属于类，不属于对象，直接用类名调用
	7、静态方法不能访问非静态属性和方法，只能访问静态。
	
	
*/
public class Test6{
	public static void main(String[] args){
		
		System.out.println(args.length);
		for(String s: args){
			System.out.println(s);
		}
		//Role beibei = new Role("刘备","蜀国");
		//Role yunchang = new Role("云长","蜀国");
		//Role feifei = new Role("张飞","蜀国");
		Role beibei = new Role("刘备");
		Role yunchang = new Role("云长");
		Role feifei = new Role("张飞");
		
		System.out.println(beibei.getInfo());
		System.out.println(yunchang.getInfo());
		System.out.println(feifei.getInfo());
		
		System.out.println(beibei.country);
		System.out.println(yunchang.country);
		System.out.println(feifei.country);
		
		beibei.country = "秦国";
		System.out.println("------------------");
		System.out.println(beibei.country);
		System.out.println(yunchang.country);
		System.out.println(feifei.country);
		
		System.out.println("------------------");
		
		System.out.println(Role.country);//用类名调用静态变量
	}
}

//角色
class Role{
	private String name;
	static String country = "蜀国";//静态变量（全局变量）
	public Role(String name,String country){
		this.name = name;
		this.country = country;
	}
	public Role(String name){
		this.name = name;
	}
	public void setName(String name){
		this.name = name;
	}
	public String getName(){
		return name;
	}
	
	//静态方法不能访问非静态的数据
	public static void setCountry(String country){
		Role.country = country;
	}
	/*
	public void setCountry(String country){
		this.country = country;
	}
	public String getCountry(){
		return country;
	}
	*/
	public String getInfo(){
		return "name="+name+",country="+country;
	}
}

声明为static的方法有以下几条限制：
 它们仅能调用其他的static 方法。
 它们只能访问static数据。
 它们不能以任何方式引用this 或super。

什么时候使用static?
所有对象共同的属性或方法，那么我们可以定义为静态的。

主方法：
public static void main(String[] args){
//代码块
}

public：公有的，最大的访问权限
static：静态的，无需创建对象
void:：表示没有返回值，无需向JVM返回结果
main：方法名，固定的方法名
String[] args：表示参数为字符串数组，可以在调用方法时传入参数

1、普通代码块
直接写在方法中的代码块就是普通代码块
示例：
public class Demo1{
   public static void main(String []args){
      {// 普通代码块
	 String info = “局部变量-1” ; 
	 System.out.println(info) ;
      }
      String info = “局部变量-2” ;
      System.out.println(info) ;
  }
}

2、构造块是在类中定义的代码块 在创建对象时被调用 优于构造方法执行
示例：
class Demo{
   {	// 构造块
	System.out.println("构造块") ;
   }
   public Demo(){
	System.out.println("构造方法。") ;
   }
}

跟写的位置没关系 先执行 代码块 再执行构造方法

3、在类中使用static声明的代码块称为静态代码块
示例：
class Demo{
  {
	System.out.println("构造块") ;
  }
  static{
	System.out.println("静态代码块") ;
  }
  public Demo(){
	System.out.println("构造方法。") ;
  }
};




4、同步代码块（多线程中讲解）

代码块：
1、普通代码块，在方法中写的代码块
2、构造块，是在类中定义的代码块，在创建对象时被调用，优于构造方法执行
3、在类中使用static声明的代码块称为静态代码块
	在第一次使用的时候被调用（创建对象），只会执行一次，优于构造块执行
	我们在项目开发中，通常会使用静态代码块来初始化只调用一次的数据。
小结：重点会使用的顺序是静态代码块，普通代码块，同步代码块，构造代码块

/**
	代码块：
	1、普通代码块，在方法中写的代码块
	2、构造块，是在类中定义的代码块，在创建对象时被调用，优于构造方法执行
	3、在类中使用static声明的代码块称为静态代码块
		在第一次使用的时候被调用（创建对象），只会执行一次，优于构造块执行
		我们在项目开发中，通常会使用静态代码块来初始化只调用一次的数据。比如说：
	小结：重点会使用的顺序是静态代码块，普通代码块，同步代码块，构造代码块

*/
public class Test7{
	public static void main(String[] args){
		
		//Student s = new Student();
		//Student s1 = new Student();
		//Student s = null;
	}
}

class Student{
	
	static{
		System.out.println("我是静态代码块");
	}
	
	public Student(){
		System.out.println("构造方法");
	}
	{
		System.out.println("我是构造代码块");
	}
	public void study(){
		
		//限制作用域
		{
			int i = 10;
			System.out.println("我是普通代码块");
		}
		
		
	}
}