2、对象数组的使用
{
//为了方便,属性暂时不封装
String name ;
int age ;
//所在城市默认为南京
String city = "南京" ;
public Person(String name,int age)
{
this.name = name ;
this.age = age ;
}
public String getInfo()
{
return "姓名:"+name+",年龄:"+age+",城市:"+city ;
}
};
public class Demo01
{
public static void main(String args[])
{
Person p1 = new Person("张三",30) ;
Person p2 = new Person("李四",31) ;
Person p3 = new Person("王五",32) ;
System.out.println(p1.getInfo()) ;
System.out.println(p2.getInfo()) ;
System.out.println(p3.getInfo()) ;
}
};
那么这样的设计就会存在问题:
1、 属性的内容重复存在,所有对象都有此属性
2、 如果现在假设南京变为北京了,假设已经产生了100000个对象,则此时如果要修改其所在城市属性的内容,则肯定要修改100000遍
· 所有的对象都共同指向同一个city属性是最好的,有一个对象将city属性修改了,则其他的也会影响。此时就需要使用static标识city属性了。
{
//为了方便,属性暂时不封装
String name ;
int age ;
//所在城市默认为南京
static String city = "南京" ;
public Person(String name,int age)
{
this.name = name ;
this.age = age ;
}
public String getInfo()
{
return "姓名:"+name+",年龄:"+age+",城市:"+city ;
}
};
public class Demo02
{
public static void main(String args[])
{
Person p1 = new Person("张三",30) ;
Person p2 = new Person("李四",31) ;
Person p3 = new Person("王五",32) ;
System.out.println(p1.getInfo()) ;
System.out.println(p2.getInfo()) ;
System.out.println(p3.getInfo()) ;
}
};
{
//为了方便,属性暂时不封装
String name ;
int age ;
//所在城市默认为南京
static String city = "南京" ;
public Person(String name,int age)
{
this.name = name ;
this.age = age ;
}
public String getInfo()
{
return "姓名:"+name+",年龄:"+age+",城市:"+city ;
}
};
public class Demo03
{
public static void main(String args[])
{
Person p1 = new Person("张三",30) ;
Person p2 = new Person("李四",31) ;
Person p3 = new Person("王五",32) ;
System.out.println("----------修改city属性之前----------") ;
System.out.println(p1.getInfo()) ;
System.out.println(p2.getInfo()) ;
System.out.println(p3.getInfo()) ;
System.out.println("----------修改city属性之后----------") ;
//通过一个对象修改city属性值
p1.city = "北京" ;
System.out.println(p1.getInfo()) ;
System.out.println(p2.getInfo()) ;
System.out.println(p3.getInfo()) ;
}
};
但是以上的程序有一些不妥,一个城市改变是应该由某个人(某个对象)去做的吗?应该是由对象的集合体去做,对象的集合体就是类,所以一般在访问static属性的时候都采用如下格式:
· 类名称.static属性 这是最合理的。
{
//为了方便,属性暂时不封装
String name ;
int age ;
//所在城市默认为南京
static String city = "南京" ;
public Person(String name,int age)
{
this.name = name ;
this.age = age ;
}
public String getInfo()
{
return "姓名:"+name+",年龄:"+age+",城市:"+city ;
}
};
public class Demo04
{
public static void main(String args[])
{
Person p1 = new Person("张三",30) ;
Person p2 = new Person("李四",31) ;
Person p3 = new Person("王五",32) ;
System.out.println("----------修改city属性之前----------") ;
System.out.println(p1.getInfo()) ;
System.out.println(p2.getInfo()) ;
System.out.println(p3.getInfo()) ;
System.out.println("----------修改city属性之后----------") ;
//通过一个对象修改city属性值
//最好是通过类名称去修改static属性,即static属性可以被类名称直接访问
Person.city = "北京" ;
System.out.println(p1.getInfo()) ;
System.out.println(p2.getInfo()) ;
System.out.println(p3.getInfo()) ;
}
};
{
//为了方便,属性暂时不封装
private String name ;
private int age ;
//所在城市默认为南京
private static String city = "南京" ;
//只编写一个可以修改city的方法
public static void setCity(String city)
{
this.city = city ;
}
public Person(String name,int age)
{
this.name = name ;
this.age = age ;
}
public String getInfo()
{
return "姓名:"+name+",年龄:"+age+",城市:"+city ;
}
};
public class Demo05
{
public static void main(String args[])
{
Person p1 = new Person("张三",30) ;
Person p2 = new Person("李四",31) ;
Person p3 = new Person("王五",32) ;
System.out.println("----------修改city属性之前----------") ;
System.out.println(p1.getInfo()) ;
System.out.println(p2.getInfo()) ;
System.out.println(p3.getInfo()) ;
System.out.println("----------修改city属性之后----------") ;
//通过一个对象修改city属性值
//最好是通过类名称去修改static属性,即static属性可以被类名称直接访问
//Person.city = "北京" ;
Person.setCity("无锡") ;
System.out.println(p1.getInfo()) ;
System.out.println(p2.getInfo()) ;
System.out.println(p3.getInfo()) ;
}
};
{
//为了方便,属性暂时不封装
private String name ;
private int age ;
//所在城市默认为南京
private static String city = "南京" ;
//只编写一个可以修改city的方法
public static void setCity(String c)
{
//this是表示当前对象,static属性是绝对不能用this表示滴~
//因为static属性不绝对属于某一个对象
//this.city = city ; ---->这是错误滴哈~~~
city = c ;
}
public Person(String name,int age)
{
this.name = name ;
this.age = age ;
}
public String getInfo()
{
return "姓名:"+name+",年龄:"+age+",城市:"+city ;
}
};
public class Demo06
{
public static void main(String args[])
{
Person p1 = new Person("张三",30) ;
Person p2 = new Person("李四",31) ;
Person p3 = new Person("王五",32) ;
System.out.println("----------修改city属性之前----------") ;
System.out.println(p1.getInfo()) ;
System.out.println(p2.getInfo()) ;
System.out.println(p3.getInfo()) ;
System.out.println("----------修改city属性之后----------") ;
//通过一个对象修改city属性值
//最好是通过类名称去修改static属性,即static属性可以被类名称直接访问
//Person.city = "北京" ;
// 使用static声明的方法可以直接使用类名称调用
Person.setCity("无锡") ;
System.out.println(p1.getInfo()) ;
System.out.println(p2.getInfo()) ;
System.out.println(p3.getInfo()) ;
}
};
1、使用static声明的方法能否访问static声明的属性呢?允许的
{
static String name = "Michael" ;
public static void fun()
{
System.out.println(name);
}
};
{
String name = "Michael" ;
public static void fun()
{
System.out.println(name);
}
};
{
static String name = "Michael" ;
public void fun()
{
System.out.println(name);
}
};
{
String name = "Michael" ;
public void fun()
{
System.out.println(name);
}
};
· 之前讲解方法的时候给了一个限制:如果一个方法想被主方法直接调用,则此方法声明时必须加上public static才可以。
{
public static void main(String args[])
{
fun();
}
public static void fun()
{
System.out.println("http://redking.blog.51cto.com");
}
};
{
public static void main(String args[])
{
fun();
}
public void fun()
{
System.out.println("http://redking.blog.51cto.com");
}
};
{
//static类型的方法只能调用static类型的方法
public static void main(String args[])
{
//如果fun()方法前不加static,则只能这样调用
new Demo13().fun();
}
public void fun()
{
System.out.println("http://redking.blog.51cto.com");
}
};
{
public static void main(String args[])
{
for (int i=0;i<args.length ;i++ )
{
System.out.println(args[i]);
}
}
};
{
public static void main(String args[])
{
//必须输入两个参数
if (args.length!=2)
{
//表示不是两个参数,则要退出系统
System.out.println("运行参数不正确,正确的格式为:");
System.out.println("java Demo15 用户名 密码");
System.exit(1);
}
//之后的程序就表示肯定已经成功的输入了用户名和密码哈~~~
String userName = args[0];
String userPasswd = args[1];
//判断用户名是否为abc,密码是否为123哈~~~
//为什么现在要用字符串.equals去判断而不是用username调用equals哈~
//这样可以有效滴避免NullPointerException
if ("abc".equals(userName)&&"123".equals(userPasswd))
{
System.out.println("欢迎访问哈~~~");
}
else
{
System.out.println("用户名和密码不正确哈~~~");
}
}
};
{
public static void main(String args[])
{
String str = "http://redking.blog.51cto.com";
System.out.println(str.equals("http://redking.blog.51cto.com"));
}
};
{
public static void main(String args[])
{
String str = null;
System.out.println(str.equals("http://redking.blog.51cto.com"));
}
};
{
public static void main(String args[])
{
String str = null;
System.out.println("http://redking.blog.51cto.com".equals(str));
}
};
· 如果现在想统计一个类到底产生了多少个对象时,就需要使用static关键字了,因为所有的对象都只拥有同一个static类型的属性。
{
private static int count = 1;
public Demo()
{
System.out.println("产生了"+(count++)+"个对象~~~~");
}
}
public class Demo19
{
public static void main(String args[])
{
new Demo();
new Demo();
new Demo();
new Demo();
new Demo();
}
};
1、普通代码块:是直接写在各个方法中的代码块
{
public static void main(String args[])
{
//普通代码块
{
int i = 10;
System.out.println(i);
}
//在代码块里定义的变量实际上是一个局部变量
int i = 99;
System.out.println(i);
}
};
{
{
//构造块
System.out.println("Demo类中的构造块~~~");
}
}
public class Demo21
{
public static void main(String args[])
{
new Demo();
new Demo();
new Demo();
new Demo();
new Demo();
}
};
{
{
//构造块
System.out.println("Demo类中的构造块~~~");
}
Demo()
{
System.out.println("Demo类中的构造方法~~~");
}
}
public class Demo22
{
public static void main(String args[])
{
new Demo();
new Demo();
new Demo();
new Demo();
new Demo();
}
};
作用:为static类型的属性初始化
{
{
//构造块
System.out.println("Demo类中的构造块~~~");
}
Demo()
{
System.out.println("Demo类中的构造方法~~~");
}
//静态块
static
{
System.out.println("Demo类中的静态块~~~");
}
}
public class Demo23
{
public static void main(String args[])
{
new Demo();
new Demo();
new Demo();
new Demo();
new Demo();
}
};
{
{
//构造块
System.out.println("Demo类中的构造块~~~");
}
Demo()
{
System.out.println("Demo类中的构造方法~~~");
}
//静态块
static
{
System.out.println("Demo类中的静态块~~~");
}
}
public class Demo24
{
//在主类中写的静态块要优先于main方法执行
static{
System.out.println("##################");
}
public static void main(String args[])
{
new Demo();
new Demo();
new Demo();
new Demo();
new Demo();
}
};
能不能不写主方法而打印出“HELLO WORLD”? 肯定可以,使用静态块哈~
{
//在主类中写的静态块要优先于main方法执行
static{
System.out.println("Hello World!!!");
}
};
{
//在主类中写的静态块要优先于main方法执行
static{
System.out.println("Hello World!!!");
//为了防止程序继续向后执行,去找main方法,此处可以使系统退出
System.exit(1);
}
};
可以声明一个属性,也可以声明一个方法,同样也可以使用private声明一个构造方法。
{
private Single(){}
public void print(){
System.out.println("Hello World~~~");
}
}
public class Demo27
{
public static void main(String args[])
{
//如果想调用print方法,则必须产生Single类的实例化对象
Single s = null;
s = new Single();
}
};
{
private Single(){}
public void getInstance()
{
//可以在类的内部产生自己的实例化对象
new Single();
}
public void print(){
System.out.println("Hello World~~~");
}
}
public class Demo27
{
public static void main(String args[])
{
//如果想调用print方法,则必须产生Single类的实例化对象
Single s = null;
//s = new Single();
// 对象有引用传递。有没有一种可能可以在Single类的内部产生自己的对象呢?
}
};
{
private Single(){}
public static Single getInstance()
{
//可以在类的内部产生自己的实例化对象
return new Single();
}
public void print(){
System.out.println("Hello World~~~");
}
}
public class Demo27
{
public static void main(String args[])
{
//如果想调用print方法,则必须产生Single类的实例化对象
Single s = null;
s = Single.getInstance();
// 对象有引用传递。有没有一种可能可以在Single类的内部产生自己的对象呢?
s.print();
}
};
一个类的构造方法如果被私有化了,则外部肯定无法看见,则此时就可以在类的内部产生实例化对象之后将此对象传递到外面去就可以了。
· 如果一个类只能要求有一个实例化对象的时候呢?
· 唯一可以做的就是在产生实例化对象的入口处加入限制 —— 构造方法的私有化
单态设计:
class Single
{
//在类内部产生自己的实例化对象,只实例化一次
private static Single s = new Single();
private Single(){}
public static Single getInstance()
{
//可以在类的内部产生自己的实例化对象
return s;
}
public void print(){
System.out.println("Hello World~~~");
}
}
public class Demo27
{
public static void main(String args[])
{
//如果想调用print方法,则必须产生Single类的实例化对象
Single s1 = null;
s1 = Single.getInstance();
// 对象有引用传递。有没有一种可能可以在Single类的内部产生自己的对象呢?
s1.print();
//要产生第二个对象,也是取滴s对象
Single s2 = Single.getInstance();
System.out.println(s2);
System.out.println(s1);
}
};