马士兵J2SE-第三章-面向对象-Object类：toString方法、equals方法、对象转型、抽象类抽象方法、final关键字、接口

toString方法

public class test {
	public static void main(String[] args) {
		Teacher t=new Teacher();
		System.out.println("1 "+t+" 2 "+t.toString());
	}
}

class Teacher {
	public String toString() {
		return "I am a teacher";
	}
}

输出：

1 I am a teacher 2 I am a teacher

说明：

public String toString() {return "I am a teacher";}不能写成大写的public String ToString！

重写必须要COPY过来！

toString

public String toString()
返回该对象的字符串表示。通常，toString 方法会返回一个“以文本方式表示”此对象的字符串。结果应是一个简明但易于读懂的信息表达式。建议所有子类都重写此方法。

Object 类的 toString 方法返回一个字符串，该字符串由类名（对象是该类的一个实例）、at 标记符“@”和此对象哈希码的无符号十六进制表示组成。换句话说，该方法返回一个字符串，它的值等于：

getClass().getName() + '@' + Integer.toHexString(hashCode())
返回：
该对象的字符串表示形式。

认识一下toString方法，并且重写父类方法！

 

 equals方法：

public class test {
	public static void main(String[] args) {
		Cat c1=new Cat(1,2,3);
		Cat c2=new Cat(1,2,3);
		System.out.println(c1==c2);
	}
}

class Cat {
   	int color;
    int height,weight;
    public Cat(int color,int height,int weight) {
    	this.color=color;
    	this.height=height;
    	this.weight=weight;
    }
}

//永远不等，比较的是地址

输出：

false

 

 

public class test {
	public static void main(String[] args) {
		Cat c1=new Cat(1,2,3);
		Cat c2=new Cat(1,2,3);
		System.out.println(c1==c2);
		System.out.println (c1.equals(c2));
	}
}

class Cat {
   	int color;
    int height,weight;
    public Cat(int color,int height,int weight) {
    	this.color=color;
    	this.height=height;
    	this.weight=weight;
    }

    //重写方法
    public boolean equals(Object obj) {
    	return true;
    }//永远都相等，不好！就是写在这里需要注意一下重写要从JDK文档中COPY一下
}

//永远不等，比较的是地址

输出：

 false
true

 

 重写equals方法正确写法

public class test {
	public static void main(String[] args) {
		Cat c1=new Cat(1,2,3);
		Cat c2=new Cat(1,2,3);
		System.out.println(c1==c2);
		System.out.println (c1.equals(c2));
	}
}

class Cat {
   	int color;
    int height,weight;

    public Cat(int color,int height,int weight) {
    	this.color=color;
    	this.height=height;
    	this.weight=weight;
    }

    //重写方法
    public boolean equals(Object obj) {
    	if(obj==null) return false;
    	else {
    		if(obj instanceof Cat) {//如果obj是猫对象的一个引用
    			Cat c=(Cat)obj;//obj强制转化为猫类型
    			if(c.color==this.color&&c.height==this.height&&c.weight==this.weight) {
    				return true;
    			}
    		}
    	}
    	return false;
    }
}

输出：

false
true

 

 

public class test {
	public static void main(String[] args) {
		Cat c1=new Cat(1,2,3);
		Cat c2=new Cat(1,2,3);
		System.out.println(c1==c2);
		System.out.println (c1.equals(c2));

		String s1=new String("Hello");
		String s2=new String("Hello");
		System.out.println(s1==s2);

		//java.lang包下的string重写了equals方法
		//将此字符串与指定的对象比较。当且仅当该参数不为 null，并且是与此对象表示相同字符序列的 String 对象时，结果才为 true。
		System.out.println(s1.equals(s2));//s2不为空，是true
	}
}

class Cat {
   	int color;
    int height,weight;

    public Cat(int color,int height,int weight) {
    	this.color=color;
    	this.height=height;
    	this.weight=weight;
    }

    //重写方法
    public boolean equals(Object obj) {
    	if(obj==null) return false;
    	else {
    		if(obj instanceof Cat) {//如果obj是猫对象的一个引用
    			Cat c=(Cat)obj;//obj强制转化为猫类型
    			if(c.color==this.color&&c.height==this.height&&c.weight==this.weight) {
    				return true;
    			}
    		}
    	}
    	return false;
    }
}

输出：

 false
true
false
true

equals

public boolean equals(Object obj)
指示其他某个对象是否与此对象“相等”。

equals 方法在非空对象引用上实现相等关系：

  • 自反性：对于任何非空引用值 x，x.equals(x) 都应返回 true。
  • 对称性：对于任何非空引用值 x 和 y，当且仅当 y.equals(x) 返回true 时，x.equals(y) 才应返回true。
  • 传递性：对于任何非空引用值 x、y 和 z，如果
    x.equals(y)     返回 true，并且 y.equals(z) 返回 true，那么x.equals(z) 应返回true。
  • 一致性：对于任何非空引用值 x 和 y，多次调用 x.equals(y) 始终返回true 或始终返回false，前提是对象上equals 比较中所用的信息没有被修改。
  • 对于任何非空引用值 x，x.equals(null) 都应返回 false。

Object 类的 equals 方法实现对象上差别可能性最大的相等关系；即，对于任何非空引用值 x 和y，当且仅当x 和y 引用同一个对象时，此方法才返回true（x == y 具有值true）。

注意：当此方法被重写时，通常有必要重写 hashCode 方法，以维护 hashCode 方法的常规协定，该协定声明相等对象必须具有相等的哈希码。

参数：
obj - 要与之比较的引用对象。
返回：
如果此对象与 obj 参数相同，则返回 true；否则返回 false。
另请参见：
hashCode(), Hashtable

 对象转型：

class Animal {
	public String name;
	Animal(String name) {
		this.name=name;
	}
}

class Cat extends Animal {
	public String eyesColor;
	Cat(String n,String c) {
		super(n);
		eyesColor=c;
	}
}

class Dog extends Animal {
	public String furcolor;
	Dog(String n,String c) {
		super(n);
		furcolor=c;
	}
}

public class test {
	public static void main(String[] args) {
		Animal a=new Animal("name");
		Cat c=new Cat("name","blue");
		Dog d=new Dog("dogname","black");

		System.out.println(a instanceof Animal);//true
		System.out.println(c instanceof Animal);//true
		System.out.println(d instanceof Animal);//true
		System.out.println(a instanceof Cat);//false

		a=new Dog("bigyellow","yellow");;
		System.out.println(a.name);//bigyellow
		//System.out.println(a.furname);//error!
		System.out.println(a instanceof Animal);//true
		System.out.println(a instanceof Dog);//true
		Dog d1=(Dog)a;//要加强制你转换符
		System.out.println(d1.furcolor);//yellow

	}
}

输出：

true
true
true
false
bigyellow
true
true
yellow

 

 

class Animal {
	public String name;
	Animal(String name) {
		this.name=name;
	}
}

class Cat extends Animal {
	public String eyesColor;
	Cat(String n,String c) {
		super(n);
		eyesColor=c;
	}
}

class Dog extends Animal {
	public String furcolor;
	Dog(String n,String c) {
		super(n);
		furcolor=c;
	}
}

public class test {
	public static void main(String[] args) {
		test testdemo=new test();
		Animal a=new Animal("name");
		Cat c=new Cat("catname","blue");
		Dog d=new Dog("dogname","black");
		testdemo.f(a);
		testdemo.f(c);
		testdemo.f(d);
	}

	public void f(Animal a) {
		System.out.println("name:"+a.name);
		if(a instanceof Cat) {
			Cat cat=(Cat) a;
			System.out.println(" "+cat.eyesColor+" eyes");
		}
			else if(a instanceof Dog) {
				Dog dog =(Dog) a;
				System.out.println(" "+dog.furcolor+" fur");
			}
	}
}

输出：

name:name
name:catname
 blue eyes
name:dogname
 black fur

abstract class Animal {//有了抽象方法，这个类必须被声明为抽象类
  private String name;
  Animal(String name) {this.name = name;}
  /*
  public void enjoy(){
    System.out.println("叫声......");
  }
  */
  //抽象类的方法没有写的必要
  public abstract void enjoy();//只有;没有左右大括号定义，相当于C++里的纯虚函数
}

abstract class Cat extends Animal {
  private String eyesColor;
  Cat(String n,String c) {super(n); eyesColor = c;}
  /*
  public void enjoy() {
    System.out.println("猫叫声......");
  }
  */
  //public abstract void enjoy();
}

class Dog extends Animal {
  private String furColor;
  Dog(String n,String c) {super(n); furColor = c;}

  public void enjoy() {
    System.out.println("狗叫声......");
  }
}

class Bird extends Animal {
	 Bird() {
	 	 super("bird");
	 }
	 public void enjoy() {
    System.out.println("鸟叫声......");
  }
}

class Lady {
    private String name;
    private Animal pet;
    Lady(String name,Animal pet) {
        this.name = name; this.pet = pet;
    }
    public void myPetEnjoy(){pet.enjoy();}
}

public class test {
    public static void main(String args[]){
        //Cat c = new Cat("catname","blue");//抽象的类是残缺的类，NEW不出来
        Dog d = new Dog("dogname","black");
        Bird b = new Bird();
        //Lady l1 = new Lady("l1",c);
        Lady l2 = new Lady("l2",d);
        Lady l3 = new Lady("l3",b);
       //l1.myPetEnjoy();
        l2.myPetEnjoy();
        l3.myPetEnjoy();
    }
}

输出：

狗叫声......
鸟叫声......

 

 final关键字

public class test {
	public static void main(String[] args) {
		T t=new T();
		System.out.println(t.i);
	}
}

final class T {
	final int i = 8;
	public final void m() {
		//j=9;
	}
}

输出：

8

说白了，就是只可以读不可以写

 

 

 

 接口：

interface Singer {
	public void sing();
	public void sleep();
}

interface Painter {
	public void paint();
	public void eat();
}

class Student implements Singer {
	private String name;

	Student(String name) {
		this.name=name;
	}

	public void study() {
		System.out.println("studying");
	}

	public String getName() {
		return name;
	}

	public void sing() {
		System.out.println("student is singing");
	}

	public void sleep() {
		System.out.println("student is sleeping");
	}
}

class Teacher implements Singer,Painter {
	private String name;

	public String getString() {
		return name;
	}

	Teacher(String name) {this.name=name;}

	public void teach() {
		System.out.println("teacher is teaching");
	}

	public void sing() {
		System.out.println("teacher is singing");
	}
	public void sleep() {
		System.out.println("teacher is sleeping");
	}
	public void eat() {
		System.out.println("teacher is eating");
	}

	@Override
	public void paint() {
		// TODO Auto-generated method stub
		System.out.println("teacher is painting");
	}
}

public class test {
	public static void main(String[] args) {
		Singer s1=new Student("tom");
		s1.sing();
		s1.sleep();
		Teacher t1=new Teacher("jack");
		t1.eat();
		t1.sing();
		t1.sleep();
		t1.paint();
		Painter p1=(Painter)t1;
		p1.paint();
		p1.eat();
	}

}

输出：

student is singing
student is sleeping
teacher is eating
teacher is singing
teacher is sleeping
teacher is painting
teacher is painting
teacher is eating

 

 

 

 

时间： 2024-12-25 23:17:22

马士兵J2SE-第三章-面向对象-Object类：toString方法、equals方法、对象转型、抽象类抽象方法、final关键字、接口的相关文章

马士兵 J2SE 第11章 GUI编程 GUI初步和布局管理器

/* 范例名称:Frame 应用举例 * 源文件名称:TestFrame.java * 要 点:Frame组件的创建及显示设置 */ import java.awt.*; public class TestFrame { public static void main( String args[]) { Frame f = new Frame("My First Test"); f.setLocation(300, 300); f.setSize( 170,100); f.setBac

马士兵 J2SE 第11章 GUI编程 事件模型ACTIONEVENT TEXTFIELD事件监听 内部类 PAINT adapter和repaint window事件 键盘事件

BUTTON事件监听 package com.zzk.cn; import java.awt.*; import java.awt.event.*; public class TestActionEvent { public static void main(String[] args) { Frame f=new Frame("Test"); Button b=new Button("Press Me!"); Monitor bh=new Monitor(); b

C#使用Object类实现栈的方法详解_C#教程

本文实例讲述了C#使用Object类实现栈的方法.分享给大家供大家参考,具体如下: Stack类的代码: using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace 使用Object类实现后进先出队列 { class Stack { private Object[] _items; public Object[] Items { get { return this.

马士兵J2SE-第三章-面向对象-基础及重载

面向对象: //面向对象的方法写一段程序,要求能够手动修改年月日的信息 class Date { private int day; private int month; private int year; public Date (int d, int m, int y) { day = d; month = m; year = y; } public void setDay(int d) { day=d; } public void setMonth(int m) { month = m; }

java中三种方式获得类的字节码文件对象

package get_class_method; public class ReflectDemo { /** * @param args */ public static void main(String[] args) { getClassObject1(); getClassObject2(); getClassObject3(); } public static void getClassObject1(){ Person p = new Person(); System.out.pr

马士兵J2SE-第三章-面向对象-static、继承、重写、构造函数

  static关键字 静态成员变量    public class Cat{ private static int sid=0; private String name; int id; Cat(String name){ this.name=name; id=sid++; } public void info(){ System.out.println("My name is "+name+" No."+id); } public static void mai

java学习笔记6--类的继承、Object类

1.类的继承 一种由已有的类创建新类的机制,是面向对象程序设计的基石之一.通过继承,可以根据已有类来定义新类,新类拥有已有类的所有功能 Java只支持单继承,每个子类只能有一个直接父类,父类是所有子类的公共属性及方法的集合,子类则是父类的特殊化,继承机制可以提高程序的抽象程度,提高代码的可重用性 基类(base class),也称超类(superclass),是被直接或间接继承的类 派生类(derived-class),也称子类 (subclass),继承其他类而得到的类,继承所有祖先的状态和行

java基础之Object类_java

Object 类位于 java.lang 包中,是所有 Java 类的祖先,Java 中的每个类都由它扩展而来. 定义Java类时如果没有显示的指明父类,那么就默认继承了 Object 类.例如: public class Demo{ // ... } 实际上是下面代码的简写形式: public class Demo extends Object{ // ... } 在Java中,只有基本类型不是对象,例如数值.字符和布尔型的值都不是对象,所有的数组类型,不管是对象数组还是基本类型数组都是继承自

马士兵J2SE-第六章-常用类-基本数据类型包装类、Maths类、File类

基本数据类型包装类 public class test { public static void main(String[] args) { Integer i=new Integer(100); Double d=new Double("123.456"); int j=i.intValue()+d.intValue(); float f=i.floatValue()+d.floatValue(); System.out.println(j); System.out.println(