一 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{}