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);
}
}