面向对象(上)

原创 2015年07月09日 11:20:44

一、Object类是所有类的基类。
Object类的几个常见方法:
toString():当输出一个对象,系统默认调用其toString方法。通常我们需要重写toString方法。
equals(Object obj) :判断其他某个对象是否与此对象“相等”。 当且仅当两个引用指向同一个对象时,才返回true;String、Data等类重写了该方法,对象值相等时,返回true;注:s1==s2当且仅当s1和s2指向同一块内存单元时,才相等。
String类重写了Object类的hashCode方法 ,使得值相同的hash码相同。

    public int hashCode() {
        int h = hash;
        if (h == 0 && value.length > 0) {
            char val[] = value;

            for (int i = 0; i < value.length; i++) {
                h = 31 * h + val[i];
            }
            hash = h;
        }
        return h;
    }

示例

public class HashCodeDemo {
    public static void main(String[] args) {
        StringBuffer sb1 = new StringBuffer("abc");
        StringBuffer sb2 = new StringBuffer("abc");
        String str3 = new String("abc");
        String str4 = new String("abc");
        System.out.println(sb1.hashCode());
        System.out.println(sb2.hashCode());
        System.out.println(str3.hashCode());
        System.out.println(str4.hashCode());
    }

}

输出结果

23979164
29094346
96354
96354

StringBuffer类没有重写hashCode方法,直接继承了Object类的hashCode方法。String类重写了该方法,使得相同的内容hashCode也相同。注:重写equals方法必须重写hashCode方法。


public class EqualsTest {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
       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;
    int weight;
    public Cat(int color,int height,int weight){
        this.color = color;
        this.height = height;
        this.weight = weight;
    }

}

输出结果:

false
false

默认情况下,s1==s2和s1.equals(s2)都是判定s1和s2是否指向同一个引用。所以返回false。
重写equals方法


public class EqualsTest {
    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;
    int 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) {
            Cat c = (Cat) obj;
            if (color == c.color && height == c.height && weight == c.weight) {
                return true;
            }
        }
        return false;
    }
}

返回结果

false
true

二、对象转型
假若猫是动物的子类。动物有eat()方法。
则:Animal a = new Cat();//此时就是类型的提升,就是向上转型。
a.eat();
Cat c = (Cat) a;//强制将父类的引用转成子类类型。向下转型。
c.catchMouse();

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 TestDemo {
    public static void main(String[] args) {
          Animal a = new Animal("name");
          Cat c = new Cat("catName","blue");
          Dog d = new Dog("dogName","black");
          System.out.println(a instanceof Animal);
          System.out.println(c instanceof Animal);
          System.out.println(d instanceof Animal);
          System.out.println(a instanceof Cat);
          a = new Dog("bigyellow","yellow");
          System.out.println(a.name);
          System.out.println(a instanceof Animal);
          System.out.println(a instanceof Dog);
          //强制类型转化
          Dog d1 = (Dog)a;
          System.out.println(d1.furColor);
    }

}

输出结果

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 TestDemo {
    public static void main(String[] args) {
          TestDemo test = new TestDemo();
          Animal a = new Animal("name");
          Cat c = new Cat("catName","blue");
          Dog d = new Dog("dogName","black");
          test.f(a);
          test.f(c);
          test.f(d);
    }
public void f(Animal a){
    System.out.println("name:"+a.name);
    if(a instanceof Cat){
        Cat c = (Cat)a;
        System.out.println(c.eyesColor);
    }else if(a instanceof Dog){
        Dog d = (Dog)a;
        System.out.println(d.furColor);
    }
}
}

输出结果

name:name
name:catName
blue
name:dogName
black

三、动态绑定和多态
什么是动态绑定:根据实际的传进来的对象来调用相应的方法。
多态的存在一般包含继承、方法的重写、父类引用指向子类对象。
示例分析

class Animal{
    private String name;
    Animal(String name){
        this.name = name ;
    }
    public void enjoy(){
        System.out.println("叫声...");
    }
}
class Cat extends Animal{
    private String eyesColor;
    Cat(String n,String c){
        super(n);
        eyesColor = c;
    }
    //重写enjoy方法
    public void enjoy(){
        System.out.println("猫叫声...");
    }
}
class Dog extends Animal{
    private String furColor;
    Dog(String n,String c){
        super(n);
        furColor = c;
    }
    //重写enjoy方法
    public void enjoy(){
        System.out.println("狗叫声...");
    }
}
class Lady{
    private String name;
    private Animal pet;
    Lady(String n,Animal pet){
        this.name = name;
        this.pet = pet;
    }
    public void myPetEnjoy(){
        pet.enjoy();
    }
}
public class TestDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
            Animal a = new Animal("animalName");
            Cat c = new Cat("catName","blue");
            Dog d = new Dog("dogName","black");
            Lady l = new Lady("l",a);
            Lady l1 = new Lady("l1",c);
            Lady l2 = new Lady("l2",d);
            l.myPetEnjoy();
            l1.myPetEnjoy();
            l2.myPetEnjoy();
    }

}

输出结果

叫声...
猫叫声...
狗叫声...

四、抽象类
1、用abstract关键字修饰的类为抽象类,用abstract关键字修饰的方法称为抽象方法。
2、含有抽象方法的类必须被声明为抽象类,抽象类必须被继承,抽象方法必须被重写。
3、抽象类不能实例化。
4、抽象方法只需声明,不需实现。
改写一下上面Animal的定义,将Animal声明为抽象类。

abstract class Animal{
    private String name;
    Animal(String name){
        this.name = name ;
    }
    abstract public void enjoy();//抽象方法只需声明,不需实现。

}

五、final关键字修饰
1.final 修饰类,则该类不可以被继承;
2.final修饰方法,则该方法不可以被重载;
3.final修饰属性,则该属性不能进行隐式初始化,必须先付初值或者在构造方法中赋值;
六、接口 interface
java只支持单继承,利用接口来支持多个继承关系,一个类可以实现多个接口。
1、接口是抽象方法和常量值的定义的集合
2、从本质上讲,接口是一种特殊的抽象类,这种抽象类中只包含常量和方法的定义;而没有变量和方法的实现。
3、接口定义举例

 interface Runner{
    public static final int id= 1;
    public void start();
    public void run();
    public void stop();
}

接口特性
1、一个类可以实现多个接口
2、接口中声明的属性默认为public static final,也只能是public static final
3、接口中只能定义抽象方法,这些方法默认为public的,也只能是public;
4、接口可以继承其他接口,添加新的属性和方法
5、多个无关的类可以实现同一个接口
6、一个类可以实现多个接口
7、与继承关系类似,接口和实现类之间存在多态关系

版权声明:本文为博主原创文章,未经博主允许不得转载。

C++面向对象高级编程(上)-Geekband

头文件和类声明 一定要注意使用防卫式的头文件声明: #ifndef _CLASSHEAD_ #define _CLASSHEAD_ . . . . #endif基于对象和面向对象 : 基于对象 ...
  • skyhuangdan
  • skyhuangdan
  • 2016年03月06日 11:25
  • 247

面向对象--第三篇(原型链)

JavaScript继承混入式继承for in 使用for in遍历对象1的属性,将所有的属性添加到另外一个对象2上 这时候就可以称 对象2 继承自 对象1 原型继承* 利用对象的动态特性,为原型对象...
  • angularWQ
  • angularWQ
  • 2017年03月09日 11:30
  • 182

09面向对象高级特性二

面向对象高级特性二 上转型对象(上溯) 如果A类是B类的父类,当我们用子类创建对象,并把这个对象的引用放到父类的对象中时:      A a;                          ...
  • kuangfengbuyi
  • kuangfengbuyi
  • 2011年12月09日 18:54
  • 483

JavaScript面向对象编程(6)利用原型链实现继承

继承是面向对象的特性之一,继承的主要目的就是为了重用。子类能复用父类的属性或者行为,可以极大地简化子类,避免重复定义。 继承的特征1.子对象拥有父对象的属性和方法 继承特征2:子对象“是一个”父对象,...
  • zhengwei223
  • zhengwei223
  • 2014年12月08日 21:02
  • 807

面向对象的Windows编程实战(下)

2.Window类前面,我们实现了WinApp类,它有一个WNDCLASSEX类型的成员变量,有一个初始化成员变量的构造函数,有一个注册类的成员函数下面,我们就要封装一个窗口类,在WinApp的基础上...
  • huyoo
  • huyoo
  • 2004年10月14日 01:01
  • 2143

ES5 中的面向对象编程实现

定义类之前铺垫了函数和原型链的相关知识,有了这些,就具备了实现面向对象程序设计的两项基本技术:封装和继承。封装就是抽象出类型,封装成一个类。例如水果,我们构造一个水果类,函数作为构造函数,容纳私有属性...
  • qingyafan
  • qingyafan
  • 2016年08月22日 17:08
  • 945

Java Bean 知乎回答以及王垠对面向对象的理解

在搜索关于 Java Bean 的相关知识,在知乎上看到一篇非常不错回答。 这个回答有点类似于之类 WY 的博客中看到的,那里面的事例也很好的讲述了关于 Java Bean 的概念,虽然作者没有说明那...
  • huangzhen0914
  • huangzhen0914
  • 2015年04月21日 22:10
  • 1529

面向对象 上

类可被任务是一种自定义的数据类型。可以使用类来定义变量,所有使用类定义的变量都是引用变量,他们将会引用到类的对象。类时客观世界里某一类对象的共同特征,对象时类的具体存在,java程序使用类的构造器来创...
  • wangshuai312
  • wangshuai312
  • 2012年05月21日 11:04
  • 123

面向对象上

面向对象   01、特征 (1)    封装(Encapsulation) (2)    继承(Inheritance) (3)    多态(Polymorphism)   02、类与对...
  • li13557498250
  • li13557498250
  • 2014年05月04日 03:09
  • 295

面向对象(上)

面向对象(上) Java是面向对象的程序设计语言。支持面向对象的三大特征:封装、继承和多态。封装是指将对象的状态信息隐藏在对象内部,不允许外部程序直接访问对象内部信息,而是通过该类所提供的方法来实现对...
  • gg12365gg
  • gg12365gg
  • 2016年10月06日 20:52
  • 261
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:面向对象(上)
举报原因:
原因补充:

(最多只允许输入30个字)