面向对象编程之Object类的使用
Java中所有类都直接或间接继承自java.lang.Object类
Java中任何类都继承了Object类中的方法，主要有：
toString()
当一个对象通过“+”与字符串进行连接，系统会自动调用对象的toString()方法获得对象的字符串描述信息
可以根据需要进行重写
equals()
原始功能是实现判断两个对象是否具有相同的引用；
在jdk标准库中提供了一些类，比如String,Date，他们都对equals方法进行了重写
hashcode()
clone()
getClass()
Demo:
public class ObjectDemo
{
public static void main(String[] args){
test1();
}
public static void test1(){
Student stu=new Student("jk",25);
System.out.println(stu);//系统自动调用toString()方法
Student stu2=new Student("zk",22);
System.out.println(stu.equals(stu2));
Student stu3=new Student("jk",25);//相等
System.out.println(stu.equals(stu3));
System.out.println("——————————————————————————————————");
}
}
//重写toString，重写equals 类示例
class Student// extends Object
{
private String name;
private int age;
public Student(String name,int age){
this.name=name;
this.age=age;
}
public String toString(){//重写toString()方法
return "学生 姓名："+name+",年龄："+age;
}
public boolean equals(Object obj){//重写equals()方法
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
Student stu = (Student)obj;
if(this.age == stu.age && this.name == stu.name) return true;
return false;
}
}效果：
面向对象编程之多态的概念和作用
多态性是指同一操作作用于某一类对象，可以有不同的解释，产生不同的执行结果
多态存在的三个必要条件
需要存在继承和实现关系
同样的方法调用而执行不同操作、运行不同代码。（重写操作）
在运行时父类或者接口的引用变量可以引用其子类的对象
多态的作用
多态通过分离做什么和怎么做，多另一个角度将接口和实现进行分离
“多态”则消除了类型之间的耦合关系
多态的存在提高了程序的扩展性和后期的可维护性
对象的上下转型
由子类转型成父类，继承图上是向上移动的，一般称为向上转型
向上转型是从一个较专用类型向通用类型转换，所以总是安全的，也就是说子类是父类的一个超集
向上转型过程中，类接口中唯一可能发生的事情是丢失方法
与向上转型相反的操作是向下转型，不安全（可能需要instanceof操作符协助）
LSP（liskov替换原则）：子类型必须能够替换掉它们的基类型
安全的向上转型的LSP的实施，充分体现继承的“is-a”关系
动态绑定与静态绑定
在程序执行前方法已经被绑定，针对java简单的可以理解为程序编译期的绑定（静态绑定），java中的方法是final,static,private和构造方法都是前期绑定的。
运行时，根据变量实际引用的对象类型决定调用哪个方法（动态绑定）
静态绑定在编译期进行
动态绑定在运行期进行
多态的概念基于对象引用的动态绑定特性
Demo:
public class AnimalDemo
{
public static void main(String[] args){
test1();
}
public static void test1(){
Animal dog=new Dog("大黄");//父类的引用变量指向子类对象，也可理解为向上转型
dog.eat();
//父类型的引用变量只能调用父类有的方法（也可以是子类重写父类的方法）
//dog.sleep();//丢失子类特有的方法（父类没有的方法）
Animal cat = new Cat("招财猫");//父类的引用变量指向子类对象，也可理解为向上转型
cat.eat();
//向下转型是不安全的
//Cat cat2 = (Cat)dog;//编译正常，运行报错：java.lang.ClassCastException: Dog cannot be cast to Cat
//cat2.eat();
if(cat instanceof Cat){//判断对象是否为特定类的实例
Cat cat2 = (Cat)cat;//向下转型
cat2.sleep();//向下转型后，可以调用子类特有的方法
}
System.out.println("——————————————————————————————————");
}
}
class Animal
{
private String name;
public String getName()
{
return name;
}
public Animal(String name){
this.name=name;
}
//通用的方法，实现没有太多的意义，只是告诉其子类去实现它
public void eat(){
}
}
class Dog extends Animal
{
public Dog(String name){
super(name);
}
public void eat(){//重写父类方法
System.out.println(this.getName()+" 啃骨头");
}
public void sleep(){
System.out.println(this.getName()+" 睡觉");
}
}
class Cat extends Animal
{
public Cat(String name){
super(name);
}
public void eat(){//重写父类方法
System.out.println(this.getName()+" 吃鱼");
}
public void sleep(){
System.out.println(this.getName()+" 睡觉");
}
}效果：