Day09 Object toString equals abstract抽象类 接口 多态

一 Object 类 老祖宗类

所有类的父类,java中所有类都直接或者间接继承自Object

1.toString()

(1).toString()将当前对象以字符串形式显示

(2).对象的十六进制的地址值

(3).在打印一个对象的引用时,默认调用对象的toString()方法

(4).对于对象类型的数据,在打印对象时,一般需要打印对象的基本信息,也就是成员属性的值

(5).所以需要对这个方法进行重写,在子类重写toString()打印当前类的对象的成员属性的值

2.equals()

比较对象是否相等的

(1)==和equals之间的区别:

基本数据类型: ==比较值

引用数据类型: == 比较地址

equals 比较两个对象的内容,但是需要进行自定义重写,否则继承自Object类中的equals方法比较的还是对象的地址

public boolean equals(Object obj) {

         return (this == obj);

     }

在现实中比较两个对象时候,一般想要根据所有属性值判断是否相等,所以需要进行重写

(2)equals重写代码

public class ObjectDemo01 extends Object{

public static void main(String[] args) {

 

Person p1=new Person("张三",18);

Person p2=new Person("张三三",17);

 

//==

System.out.println(p1==p2);  //false

System.out.println("两个对象内容是否相同:"+p1.equals(p2));  //false

 

//equals  重写

System.out.println(p1.equals(p1)); //true

}

}

class Person{

private String name;

private int age;

 

public Person() {

// TODO Auto-generated constructor stub

}

 

public Person(String name, int age) {

super();

this.name = name;

this.age = age;

}

 

//equals 两个对象如果年龄相同就是一个对象

public boolean equals(Object anObject){

//1.先判断两个对象的地址,如果地址相同证明为相同对象,属性肯定相同

if(this==anObject){

return true;

}

 

//2.参数对象anObject是否为一个Person对象,如果是才比较内容,不是没有可比性返回false

if(anObject instanceof Person){

Person p2=(Person)anObject;

return (this.age==p2.age) && (this.name.equals(p2.name));

}

return false;

}

}

(3)instanceof

Java 中的instanceof 是一个二元操作符（运算符）运算符，由于是字母组成，所以是Java的保留关键字，但是和>=，<=，==属同一类，它的作用是用来判断，instanceof 左边对象是否为instanceof 右边类的实例，返回一个boolean类型值。还可以用来判断子父类的所属关系。

二 abstract 抽象的

1.抽象类

说不清楚的类就是抽象类 ,被abstract修饰的类就是抽象类

2.抽象方法

说不清楚的方法就是抽象方法 ,被abstract修饰的方法就是抽象方法

没有方法体

必须存在于抽象类中

3.特点:

(1).抽象类不能被实例化

(2).抽象方法要存在于抽象类中

(3).抽象类中可以存在抽象方法,可以存在具体方法

(4).如何使用抽象类中的内容,需要具体子类继承,继承抽象类需要重写抽象方法

具体子类:必须重写所有抽象方法+按需添加新增方法

抽象子类:按需重写抽象方法+按需添加新增方法

(5).抽象方法怎么使用,必须要子类重写

(6).abstract关键字不能和private,final,static,native一起使用

(7).抽象方法一旦被子类重写过,就不需要在被其子类或者孙子类重写

三 多态

1.多态的理解

(1)静态绑定(静态联编):

在编译期完成，可以提高代码执行速度。

(2)静态绑定的方法

a.静态方法

b.构造器

c.private 方法

d.用关键字 super 调用的方法

(3)动态绑定(动态联编)：

指在“执行期间（而非编译期间）” 判断所引用对象的实际类型，根据其实际的类型调用其相应的 方法。 这虽然让我们编程灵活，但是降低了代码的执行速度。这也是 JAVA 比 C/C++速度慢的主要因素之一。 多态，polymorphism 即多种形态，模糊策略，以不变应万变， 使用多态可以编写更加通用的代码。 多态的概念发展出来，是以封装和继承为基础的。子类以父 类的身份出现，但做事情时还是以自己的方法实现。 相同的事物，调用其相同的方法，参数也相同时，但表现的 行为却不同。

(4)要发生多态有三个必要条件：

要有继承，要有重写，父类引 用指向子类对象

2.对象转换

一个基类的引用类型变量可以“指向”其子类的对象。 一个基类的引用不可以访问其子类对象的新增成员（包括属 性和方法）。

可以使用 “引用变量 instanceof 类名”来判断该引用类型 变量所“指向”的对象是否属于该类或该类的子类。 子类对象可以当作基类的对象来使用，称作向上转型 (upcasting)，反之称为向下转型(downcasting)

四 接口

使用interface来定义接口  

接口就是一个特殊的抽象类

1.接口的优点:

(1)提高代码的复用性

(2)定义开发规范

(3)解耦 ,高内聚低耦合

(4)接口可以多实现,类只能单继承

2.jdk1.7及之前接口的组成:

(1)只能有公共的静态的常量+公共的抽象方法组成

常量: public static final 数据类型  常量名 = 赋值;

修饰符默认是:public static final 默认的可以省略,可以选择性的省略

使用: 类名.静态常量名

 

方法:   public abstract 返回值类型 方法名(参数);

修饰符: public abstract 默认的.可以省略,可以选择性的省略

使用: 实现类对象.抽象方法名

(2)特点:

a.不能实例化 ,因为抽象方法

b.继承一个类extends ,实现一个接口implements关键字

c.类只能单继承,类多实现接口

d.接口的使用:

具体的实现类:重写所有接口中的所有抽象方法+按需新增

抽象实现类:按需重写抽象方法+按需新增

e.一个类只能单继承类,一个类可以多实现接口

f.接口不能继承类,接口可以多继承接口,接口不能实现接口

3.jdk1.8新增功能:

1.默认方法 default,可以定义多个,需要通过实现类对象使用,实现类中可以对默认方法进行重写

2.静态方法 static,需要通过接口名.静态方法名使用

public class InterfaceDemo01 {

 public static void main(String[] args) {

// MyInterface.a=10;  常量

System.out.println(MyInterface.a);

 

MyImpl my=new MyImpl();

my.haha();

my.test();

 

//MyInterface m=new MyInterface();

 

//测试接口中默认方法  实现类对象调用

ImplB im=new ImplB();

im.hehe();

im.hehe2();

//im.staticMethod();

B.staticMethod();

 

}

}

 

//具体实现类

class Concrete extends MyImpl2{

 

@Override

public void haha() {

System.out.println("hhhhhhhhhh");

}

 

}

 

//抽象实现类

abstract class MyImpl2 implements MyInterface,A{

 

@Override

public void test(){

System.out.println("实现类....");

};

 

//void haha();

 

}

 

//实现类:具体实现类,可以实例化的实现类

class MyImpl implements MyInterface,A{

 

@Override

public void test() {

System.out.println("test");

}

 

@Override

public void haha() {

System.out.println("聊天止于呵呵...,微笑");

}

 

}

 

//接口

interface MyInterface{

//公共的静态的常量

int a=5;

 

//抽象方法

void test();

}

 

interface A{

void haha();

}

 

interface B{

public default void hehe(){

System.out.println("我是接口中的默认方法");

}

public default void hehe2(){

System.out.println("我是接口中的默认方法22222");

}

//静态方法

static void staticMethod(){

System.out.println("我是接口中的静态方法");

}

}

 

//实现类

class ImplB implements B{

@Override

public void hehe2(){

System.out.println("我是被重写的那个默认方法");

}

}

 

 

interface C extends B,A{}