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("我是普通代码块");
}
}
}