[散修弟子]JAVA-3263|2018年02月22日的日报-技能树.IT修真院

发表于： 2018-02-22 20:49:15

2 629

今日完成：

1.经过搜索引擎查询，完成IDEA的配置，使字体大小合适，字体格式利于编码阅读。

2.哈希编码独一无二的代表了一个对象，并且通过哈希编码可以找到这个对象所在的位置。

3.Object类中定义有：

a. public boolean equals(Object obj)方法提供对象是否相等的逻辑；

b. Object的equals方法定义为：x.equasl(y)当x和y是同一个对象是返回true,否则返回false；

c. 提供的一些类，如String,Date等，重写了Object的equals方法，调用这些类的equals方法，x.equals(y)当x和y所引用的对象属于同一类对象且拥有相同的属性内容（并不一定是相同对象），返回true,否则返回false.

d. 可以根据需要在用户自定义类型中重写equals方法。

4.对象转型：

a. 一个基类的引用类型变量可以“指向”其子类的对象。

b. 一个基类的引用不可以访问其子类对象新增的成员属性和方法。

c. 可以使用引用 instance of 类名来判断该引用型变量所“指向”的对象是否属于该类或该类的子类。

d. 子类的对象可以当作基类的对象来使用称作向上转型（upcasting），反之称作向下转型（downcasting）。

5.代码实例：

package com.bjsxt;

public class TestCasting {
    public static void main(String[] args){
        Animal a = new Animal("name");
        Mimi c = new Mimi("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 Mimi);

        a = new Dog("bigyellow","yellow");
        System.out.println(a.name);
        /* System.out.println(a.furColor); */
        System.out.println(a instanceof Animal);
        System.out.println(a instanceof Dog);
        Dog d1 = (Dog) a;
        System.out.println(d1.furColor);
    }

}

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

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

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

true

false

bigyellow

true

yellow

Process finished with exit code 0

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

    public void f(Animal a) {
        System.out.println("name:"+a.name);
        if (a instanceof Mimi) {
            Mimi c =(Mimi)a;
            System.out.println(" "+c.eyesColor+" eyesColor");
        }
        else if (a instanceof Dog) {
            Dog d = (Dog)a;
            System.out.println(" "+d.furColor+" furColor");
        }
    }
}

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

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

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

name:name

name:catname

blue eyesColor

name:dogname

black furColor

Process finished with exit code 0

动态绑定是指在执行期间（而非编译期间）判断所引用的对象的实际类型，根据其实际的类型调用其对应的方法。

动态绑定极大的扩展了程序的重复性。

条件：1.有继承 2.有重写 3. 父类引用指向子类对象

1用abstract关键字修饰的类，叫做抽象类；用abstract来修饰一个方法时，该方法叫做抽象方法。

2含有抽象方法的类，必须为抽象类，抽象类必须被继承，抽象方法必须被重写。

3抽象类不能被实例化。

4抽象方法只需声明，不需实现。

代码实例：

package com.sxt;
 
 public class TestAbstract {
     public static void main(String[] args) {
         Cat c = new Cat("catname","blue");
         Puppy p = new Puppy("puppyname","black");
         Bird b = new Bird();
         Lady l1 = new Lady("l1",c);
         Lady l2 = new Lady("l2",p);
         Lady l3 = new Lady("l3",b);
         l1.myPetEnjoy();
         l2.myPetEnjoy();
         l3.myPetEnjoy();
 
     }
 }
 
 abstract class Animals {
     private String name;
     Animals(String name) {
         this.name = name;
     }
     public abstract void enjoy();
 }
 
 class Cat extends Animals {
     private String eyesColor;
     Cat(String n, String c) {
         super(n);
         eyesColor = c;
     }
 
     @Override
     public void enjoy() {
         System.out.println("猫叫声……");
     }
 }
 
 class Puppy extends Animals {
     private String furColor;
     Puppy(String n, String c) {
         super(n);
         furColor = c;
     }
 
     @Override
     public void enjoy() {
         System.out.println("狗叫声……");
     }
 }
 
 class Bird extends Animals {
     Bird() {
         super("Bird");
     }
 
     @Override
     public void enjoy() {
         System.out.println("鸟叫声……");
     }
 }
 
 class Lady {
     private String name;
     private Animals pet;
     Lady(String name, Animals pet) {
         this.name = name;
         this.pet = pet;
     }
 
     public void myPetEnjoy() {
         System.out.print(this.name+","+this.pet);
         pet.enjoy();
     }
 }