java_Object、抽象类、接口、多态、类与类之间的转换

package com.tz.obj;
/**
 * 父类：人类
 *          
 * @author Administrator
 *
 */
public class Person {
    String name;
    int age;
    char gender;
}

package com.tz.obj;
/**
 * 子类：学生
 * 
 * 属性：name，age，gender，
 * 
 * @author Administrator
 *
 */
public class Student extends Person{
        int idNum;

        public Student(){

        }
        public Student(String name,int age,char gender,int idNum){
            this.name = name;
            this.age = age;
            this.gender = gender;
            this.idNum = idNum;

        }

        @Override
        public String toString() {

        return "姓名："+name+"年龄"+age+"性别："+gender+"学号："+idNum;
        }

        //重写equals方法
        @Override
        public boolean equals(Object obj) {
            if(this == obj){
                return true;
            }
            if(obj instanceof Student){    //instanceof(用来判断对象):     == <  >
                Student s  = (Student)obj;    
                if(s.name.equals(name)&&s.age==this.age&&s.idNum==this.idNum){//用==比较数值，用equals比较引用数据类型。
                    return true;
                }
            }
        return false;
        }


}

package com.tz.obj;
/**
 * java中所以类的超类（基类）：
 *          Object：      java.lang  -->  系统默认导入
 *              toString()：   输出的是对象的地址
 *              equals()  :  比较的是内容，（重写了equals方法的作用是设置你想要比较的内容，不重写的话比较的是内存地址）
 * 
 *              String已经帮我们重写了toString方法
 *                      
 * @author Administrator
 *
 */
public class ObjectTest {
        public static void main(String[] args) {
            String name1 = "HB";
            String name2 = "HB";

            //创建对象
            Student s1 = new Student("影子", 12, '男', 1111);
            Student s2 = new Student("影子", 12, '男', 1111);

            System.out.println(s1);   //
            System.out.println(s2.toString());    
            System.out.println("===========================");
            System.out.println(s1==s2);   //==：比较的是内存地址
            System.out.println(s1.equals(s2));  //

            System.out.println(name1.equals(name2));
        }
}

package com.tz.abs;
/**
 * 抽象类：（本质上是一个类）
 *      1、如果一个类中含有抽象方法，那么这个类就一定是个抽象类
 *      2、抽象类可以没有抽象方法。
 *      3、抽象类不可以被实例化。
 *      4、抽象类中有构造方法的，该构造方法是给子类创建对象用的
 *      5、非抽象可以继承一个抽象类。但是必须要重写类中的抽象方法
 *      6、final 是不能修饰抽象类和抽象方法的
 * 
 * 
 * 
 * 如何定义一个抽象类？
 *          class关键字前加abstract
 * 
 * 
 * 抽象方法：
 *      [修饰符] abstract 返回值类型 方法名（）；
 *      
 *      1、被abstract修饰
 *      2、没有方法体
 *      3、以分号结尾
 *
 */
public abstract class AbstractTest {
    public void m1(){   //普通方法
        //方法体
    }

    public abstract void m2();   //抽象方法.


    public static void main(String[] args) {
        //AbstractTest ab = new AbstractTest();



    }
}

package com.tz.abs;

 public interface Interface1 extends Interface2,Interface3,Interface4 {

     //常量
     public static final String NAME ="LEJIAN"; 


     public abstract void eat();

     String m3();   //public abstract 可以省略


}
interface Interface2{

}
interface Interface3{

}
interface Interface4{

}

package com.tz.abs;
/**
 * 接口：
 * 语法：
 *      修饰符 interface 接口名{
 *  
 *      }
 * 
 * 接口也是引用数据类型，可以等同看作是一个类
 *      1、接口中只能有常量，抽象方法
 *      2、接口其实是一个特殊的抽象类，特殊在接口是完全抽象
 *      3、接口中没有构造方法，不能被实例化
 *      4、类是单继承，但是接口与接口之间多继承
 *      5、接口与类之间多实现，一个类可以实现多个接口
 *      6、实现的关键字：implements
 *      7、一个非抽象的类实现一个接口时，必须实现接口中所有的方法
 * 
 * 
 * @author Administrator
 *
 */
public class InterfaceTest implements Interface1{

    public static void main(String[] args) {
         System.out.println(InterfaceTest.NAME);

    }



    @Override
    public String m3() {
        // TODO Auto-generated method stub
        return null;
    }

    @Override
    public void eat() {
        // TODO Auto-generated method stub

    }


}

package com.tz.abs;
/**
 * 多态：
 *      生活中：同一个事物，由于条件不一样，产生的结果也不同
 *      程序中：同一个引用类型，使用不同的实例而执行不同的操作
 * 
 *          1、父类的引用指向子类的对象
 *          2、创建子类对象时，调用的方法为子类重写或继承的方法
 * @author Administrator
 *
 */
public class PolyTest {
    public static void main(String[] args) {
        //创建对象 
        Animal animal = new Dog();    //父类   new 子类    ---》多态
                    animal = new Fish();
                    //animal = new bird();

        Master master = new Master();
        Dog dog = new Dog();
        dog.name="旺财";
        //master.feed(dog);

        Fish fish = new Fish();
        fish.name="小鱼儿~";
    //  master.feed(fish);     //实际参数
    }

}

package com.tz.abs;
/**
 * 主人
 * @author Administrator
 *
 */
public class Master {
        public void feed(Dog dog){
            dog.move();
            System.out.println("我在喂汪汪汪......");
        }
        public void feed(Fish fish){   //形式参数
            fish.move();
            System.out.println("我得喂鱼了.....");
        }


        public void feed(Animal animal){
            animal.move();
            System.out.println("喂养"+animal.name);
        }


}

package com.tz.abs;
/**
 * 类与类之间的转换
 *          向上转型------    子类--》父类       自动
 *          向下转型------      父类--》子类     强制
 * @author Administrator
 *
 */
public class Test {

    public static void main(String[] args) {

        Animal dog = new Dog();    //父类的引用指向子类的对象

        //父类--》子类
        //Dog animl = (Dog) new Animal();   //强制类型转换

        Animal a = new Dog();

        if(a instanceof Dog){
            Dog d = (Dog)a;     //向下转型存在风险    
            System.out.println(d);
        }else{
            System.out.println("不是狗");
        }

        //System.out.println(animl);
    }
}