1).Person类有name,age,salary属性,要求实现至少两个构造方法,并且属性私有,提供对应的getter、setter。
2).覆写toString方法,要求在System.out.println()函数中传递Person对象能打印出三个属性值而不是对象地址。
3).覆写equals方法,要求两个Person类对象的值相同时返回true。
class Person{
private String name;
private int age;
private double salary;
public Person() {
}
public Person(String name, int age, double salary) {
this.name = name;
this.age = age;
this.salary = salary;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
public String toString() {
return "Person [name=" + name + ", age=" + age + ", salary=" + salary + "]";
}
public boolean equals(Object obj) {
if(obj==null) {
return false;
}
if(obj==this) {
return true;
}
if(obj instanceof Person) {
Person tmp = (Person)obj;
if(tmp.getAge()!=this.age) {
return false;
}
if(tmp.getName()==null) {
if(this.name!=null) {
return false;
}
}else if(!tmp.getName().equals(this.name)) {
return false;
}
if(tmp.getSalary()==this.salary) {
return true;
}
}
return false;
}
}
public class Test412 {
public static void main(String[] args) {
Person p1 = new Person();
Person p2 = new Person();
Person p3 = new Person("张三", 20, 2000.5);
Person p4 = new Person("张三", 20, 2000.5);
Person p5 = new Person("李四", 20, 2000.5);
System.out.println(p1.equals(p2));
System.out.println(p3.equals(p4));
System.out.println(p3.equals(p5));
System.out.println(p1);
System.out.println(p2);
System.out.println(p3);
System.out.println(p4);
System.out.println(p5);
}
}
//3.说出下列程序的执行结果,并说明原因:
Integer a = 55;
Integer b = 55;
System.out.println(a==b);
System.out.println(a==new Integer(55));
System.out.println(a.equals(new Integer(55)));
Integer c = 129;
Integer d = 129;
System.out.println(c==d);
结果:
1. true //直接赋值,数值在-128~127之间的数,对象会在IntegerCache.cache 产生,会复用已有对象,所以返回结果为true
2. flase //通过new在堆内存开辟新的空间,所指向的不是同一地址,地址值不同,结果为false
3. true //我们看一下Integer的equals的源码
public boolean equals(Object obj) {
if (obj instanceof Integer) {
return value == ((Integer)obj).intValue();
}
return false;
}
显然,Integer的equals的方法经过覆写了,它比较的该对象的属性value,55==55所以返回true
4. flase //如1所说的,数值129不在范围内,故在堆内存上开辟新的空间,两对象引用固然不同
懒汉单例模式和饿汉单例模式
package com;
//懒汉式单例模式
class Singleton {
private static Singleton instance;
private Singleton() {
}
public static Singleton getInstance() {
if(instance==null) {
Singleton.instance = new Singleton();
}
return instance;
}
public void print() {
System.out.println("懒汉单例模式");
}
}
//饿汉式单例模式
class SingletonH{
private final static SingletonH INSTANCE = new SingletonH();
private SingletonH() {
}
public static SingletonH getInstance() {
return INSTANCE;
}
public void print() {
System.out.println("饿汉单例模式");
}
}
public class Trst413 {
public static void main(String[] args) {
Singleton s1 = Singleton.getInstance();
Singleton s2 = Singleton.getInstance();
s1.print();
SingletonH h1 = SingletonH.getInstance();
SingletonH h2 = SingletonH.getInstance();
s2.print();
System.out.println(s1);
System.out.println(s2);
System.out.println(h1);
System.out.println(h2);
}
}
从结果上来看,两者并没有什么不同,但是懒汉式存在多线程安全问题,而饿汉式不会。
从结构上看,懒汉式的属性instance没有初始化,而饿汉式在属性上初始化,可以这样理解记忆,懒汉式懒得去初始化交给方法去做,饿汉式已经饿的不行了,急着要吃这个实例化对象。
异常处理
1).定义一个MulException类继承Exception类,要求两数相乘等于100报错,在主类中定义一个方法,在方法中抛出此异常,在主方法观察结果。
class MulException extends Exception{
public MulException() {
super("两数的乘积不能等于100");
}
}
public class Trst413 {
public static void main(String[] args) {
try {
System.out.println(mul(20, 5));
}catch (MulException e) {
e.printStackTrace();
}
}
public static int mul(int a, int b) throws MulException{
if(a*b==100) {
throw new MulException();
}
return a*b;
}
}
2).定义一个DivException类继承RuntimeException类,要求两数相除等于2报错,在主类中定义一个方法,在方法中抛出此异常,在主方法观察结果。class DivException extends RuntimeException{
public DivException(String msg) {
super(msg);
}
}
public class Trst413 {
public static void main(String[] args) {
try {
System.out.println(div(4, 2));
} catch (Exception e) {
e.printStackTrace();
}
}
public static int div(int x, int y) throws DivException{
int res=0;
res = x/y;
if(res==2) {
throw new DivException("两数相除不能等于2");
}
return res;
}
}
题目:猴子吃桃问题:猴子第一天摘下若干个桃子,当即吃了一半,还不过瘾,又多吃了一个 第二天早上又将剩下的桃子吃掉一半,又多吃了一个。以后每天早上都吃了前一天剩下的一半零一个。到第10天早上想再吃时,见只剩下一个桃子了。求第一天共摘了多少。
拿一天来举例:昨天的数量/2-1=今天的数量,则,昨天的数量=(今天的数量+1)*2,猴子是从第一天开始吃的,到第十天共吃了9天,所以只要做9次循环即可
int n = 1;
for(int i=0;i<9;i++) {
n=(n+1)*2;
}
System.out.println(n);
结果:1534