day08 ==与equals,关键字static等

day08

==与equals

==:
1.基本类型比较值,只要两个变量的值相等.ture
2.引用类型比较引用(指向对象),只指向同一个对象时, ==才返回ture
Person p = new Person();
Person p1 = new Person();
p1 == p2

equals():所有类都继承了Object,也就获得了equals()方法,还可以重写
只能比较引用类型.
格式: obj1.equals(obj2)

String s = new String(“abc”);
String s2 = new String(“abc”);

System.out.println(s1 == s2); //==比较的是对象的地址
System.out.println(s1.equals(s2)); //equals()比较的是内容

打印结果为
false
ture
除了特殊的类之外的七天普通的类的对象,==和equals比较的都是对象(对象的内存地址)

package day08;

public class Order {
	int orderId;
	String OrderName;
	
	public Order(int orderId,String OrderName) {
		this.orderId = orderId;
		this.OrderName = OrderName;
	}
	
	public int getOrderld() {
		return orderId;
	}
	public void setOrderld(int orderld) {
		this.orderId = orderld;
	}
	public String getOrderName() {
		return OrderName;
	}
	public void setOrderName(String orderName) {
		OrderName = orderName;
	}
	
	@Override
	public boolean equals(Object obj) {
		boolean flag = false;
		if(obj instanceof Order) {//比较传进来的obj类是否是Order类
			Order o = (Order) obj;//obj强转为Order类
			//Sting类型使用equals()方法
			if(this.orderId == o.orderId && this.OrderName.equals(o.OrderName)) {
				flag = true;
			}
		}
		return flag;
	}
}

调用时提示此时的equals方法为Order类的重写

package day08;

public class MyDate {
	
	int year;
	int month;
	int day;
	
	public MyDate(int year,int month,int day){
		this.year = year;
		this.month = month;
		this.day = day;
	}
	
	@Override
	public boolean equals(Object obj) {
		int flag = 0;
		if(obj instanceof MyDate) {
			MyDate md = (MyDate) obj;
			if(this.year != md.year) {
				flag += 1;
			}
			if(this.month != md.month) {
				flag += 1;
			}
			if(this.day != md.day) {
				flag += 1;
			}
		}
			if(flag == 0) {
			return true;
		}
			
			return false;
		}
}

此时调用equals方法时,提示为MyDate类下的重写

关键字static
新建Chinese类,设置类的属性

package day08;

public class Chinese {
    String country;
	String name;
	String age;

}

打印属性国籍

package day08;

public class Test {
	public static void main(String[] args) {
	
	Chinese c = new Chinese();
	c.country = "中国";
	Chinese c1 = new Chinese();
	c1.country = "中国";
	Chinese c2 = new Chinese();
	c2.country = "中国";
	}
}

输出结果为中国

但是这种方法比较繁琐,
可以使用关键字static来使类不用实例化,直接类名.属性名就可以使用
可以被这个类的实例化对象所共享,也可以叫做静态变量

package day08;

public class Chinese {
	static String country;
	String name;
	String age;

}

package day08;

public class Test {
	public static void main(String[] args) {
	
	Chinese.country = "中国";
	Chinese c = new Chinese();
	Chinese c1 = new Chinese();
 	Chinese c2 = new Chinese();

 	System.out.println(c.country);//这里的.country使用的是Chinese.country,在eclipse里,字体表现不一样
	System.out.println(c2.country);
	System.out.println(c1.country);
	}
}

此时所有类的实例化对象被共享,打印结果 中国

如果想让一个类的所有实例共享数据,就用类变量

package day08;

public class Chinese {
	
	public static void test(){
		System.out.println("这是一个static方法");
	}
}

调用方法为类名.方法

package day08;

public class Test {
	public static void main(String[] args) {
	
	Chinese.test();
	}
}

打印结果为:这是一个static方法

在有些方法不想因为对象的不同而频繁通过new对象的方式去调用方法
那么方法就使用static

因为不需要实例就可以访问static方法,因此static内部不能有this和super

设计模式

设计模式是在大量的时间中总结和理论化之后优选的代码结构,编程风格,
以及解决问题的思考方式.

单例(Singleton)设计模式
单例:只有一个实例(实例化对象)
假如构造中需要执行1000行代码,占用很大资源,耗时很长
每一次new新对象需要很久,像这种情况就适合使用单例模式.

单例设计模式分为饿汉式和

如何设计一个饿汉式单例和懒汉式单例

package day08;
/**
 * 饿汉式的单例模式
 * @author Administrator
 *
 */
public class Single {
	
	//私有的构造,构造方式私有化,调用这个类的人不能直接使用new来创建对象
	private Single() {
		
	}
	
	//私有的single类的类变量
	private static Single single = new Single();
	
	public static Single getInstance() {
		return single;
	}
}

当调用时,只能访问getInstance
Single s = Single.getInstance();
Single s1 = Single.getInstance();
Single s2 = Single.getInstance();
Single s3 = Single.getInstance();

懒汉式单例

package day08;
/**
 * 懒汉式的单例模式
 * @author Administrator
 *
 */
public class Single1 {
	//先私有化构造方法,让外边不能直接new对象
	private Single1(){
		
	}
	//私有的Single1类的变量
	private static Single1 s1 = null;
	
	public static Single1 getInstance() {
		//假如第一个没有,那么new新对象,假如后面再调用的时候!= null,则return 第一次new的对象.
		if(s1 == null) {
			s1 = new Single1();
		}
		
		return s1;
	}
}

调用方式为
Single1 s = Single1.getInstance();
Single1 s1 = Single1.getInstance();
Single1 s2 = Single1.getInstance();
Single1 s3 = Single1.getInstance();
Single1 s4 = Single1.getInstance();

懒汉式和饿汉式的区别,就是什么时候new这个对象
懒汉式,是在第一次有人调用方法时,来new对象,以后再有人调用,就直接返回第一次new好的对象,
饿汉式,是在类加载之后,还没有人调用的时候,就先new好一个对象,以后不论谁来,都是返回new好的对象.