java中抽象类怎么继承抽象类 抽象类继承object

目录索引

• Object类

• Object的tostring和equals覆写

• 抽象类

• 抽象类相关说明
• 抽象类应用：模板设计模式

Object类

主要特征： 使用object类可以接收所有的数据类型，在Java中只有object类不存在继承关系，所有类在默认情况下都是object的子类
接收一个类：

class Person { } //一个类
public class JavaDemo {
	public static void main (String args []) {
		Object obj = new Person() ; //向上转型
		if (obj instanceof Person) {
			Person per = (Person) obj ;
			System.out.println("Person对象向下转型执行完毕。") ;
		}//证明Person默认父类是Object类
	}
}

接收一个数组：

public class JavaDemo {
	public static void main (String args []) {
		Object obj = new int [] {1,2,3} ; // 向上转型
		if (obj instanceof int[]) { //是否为整型数组
			intdata[]=(int[])obj;//向下转型
			for (int temp : data) {
				System.out.print(temp + "、") ;
			}
		}
	}
}

所以Object是一个万能的类型

Object的tostring和equals覆写

Object提供的这两个方法，通常会被覆写

class Person {
	private String name ;
	private int age ;
	public Person (String name,int age) {
		this. name = name ;
		this.age = age ;
	}
	public String toString() {//此处覆写toString方法，因为Object的toString返回的是一个地址，如果不覆写，下面将打印的对象，会返回一个地址
		return "姓名:”+  + "、年龄:”+ this.age ;
	}
	public boolean equals (Object obj) {//此处覆写equals方法，因为Object的equals质提供对象地址的比较，而不提供内容的比较
		if (! (obj instanceof Person) ) {//此时比较的对象不是Person
			return false ;
		}
		if (obj == null) { // 不关心null的比较
			return false ;
		}
		if (this == obj) { // 同一个地址
			return true ;
		}
		Person per = (Person) obj ; //目的是为了获取类中的属性
		return .equals()&&this.age==per.age;
	}
}
public class JavaDemo {I
	public static void main (String args[]) {
		Person perA = new Person ("张三",18) ;
		Person perB = new Person("张三",18);
		System.out.println(per) ;//会调用Object的toString方法，覆写后调用覆写后的
		System.out.println(perA.equals(perB));//会调用Object的equals方法，覆写后调用覆写后的
	}
}

抽象类

子类是由自己决定的是否覆写，而父类无法对子类做出强制要求（强制必须覆写某个方法），这个时候，往往不会采用类的继承（在实际开发中很少会去继承一个已完善的类）而是必须要继承抽象类，进行父类的设计的时候一般考虑抽象类。
抽象类 的主要作用在于对子类中覆写方法进行约定，在抽象类里面可以去定义一些抽象方法以实现这样的约定，抽象方法指的是，使用了abstract关键字定义的并且没有提供方法体的方法，而抽象方法所在的类必须为抽象类，抽象类必须使用abstract关键字来进行定义

• 抽象类不能直接实例化
• 如果想要使用抽象类那么抽象类必须提供有子类，子类使用extends继承一个抽象类，且子类（不是抽象类）一定要覆写抽象类的全部方法
• 所以抽象类的对象实例化可以利用对象的多态性通过子类向上转型的方式完成

abstract class Message {//定义抽象类
	private String type ; //消息类型.
	public abstract String getConnectInfo() ; // 抽象方法
	public void setType(String type) { // 普通方法
		this.type = type ;
	}
	public String getType() { // 普通方法
		return this.type ;
	}
class DatabaseMessage extends Message { //类的继承关系
	public String getConnectInfo() {//方法覆写
		return "Oracle数据库连接信息。";
	}
}
public class JavaDemo {
	public static void main (String args [] ) {
		Message msg = new DatabaseMessage() ;//向上转型
		msg.setType("客户消息") ;
		System.out. println(msg. getConnectInfo()) ;
		System.out. println(msg. getType()) ;
	}
}

抽象类相关说明

1. 在定义抽象类的时候不能用final关键字来进行定义，因为抽象类有子类，而final定义的类不能有子类
2. 抽象类可以提供构造方法，并且子类也一定会按照子类对象的实例化原则进行父类构造调用
3. 抽象类中允许没有抽象方法
4. 抽象类中可以提供有static方法，并且该方法不搜到抽象类对象的局限

抽象类应用：模板设计模式

抽象类最大的好处在于对子类方法的统一管理，二是可以自身提供有一些普通方法，并且这些普通方法可以调用抽象方法

abstract class Action {//定义一个抽象类,对所有行为规范进行统一的处理（提供了一个模板）
	public static final int EAT = 1 ;
	public static final int SLEEP = 5 ;
	public static final int CODE= 10 ; .
	public void command (int number) {
		switch (number) {
			case EAT:{
				this.eat() ;
				break ;
			}
			case SLEEP : {
				this.sleep() ;
				break ;
			}
			case WORK : {
				this.code() ;
				break ;
			}
			case EAT+SLEEP+WORK:{
				this.eat() ;
				this.sleep() ;
				this.code() ;
				break;
			}
		}
	}
	public abstract void eat() ;
	public abstract void sleep() ;
	public abstract void code() ;
}
class Robot extends Action {//机器人类
	public void eat() {
		System.out.println("机器人充电。") ;
	}
	public void sleep() {
		System.out.println("机器人不需要睡觉")
	}
	public void code() {
		System.out.println("机器人按照固定的套路打代码") ;
	}
}
class Person extends Action {//人类
	public void eat() {
		System.out.println("人吃米饭或者馒头") ;
	}
	public void sleep() {
		System.out.println("人类上床睡觉")
	}
	public void code() {
		System.out.println("人类会ctrl+c") ;
	}
}
class Pig extends Action {//猪类
	public void eat() {
		System.out.println("猪吃猪草") ;
	}
	public void sleep() {
		System.out.println("猪以天为被，以地为席")
	}
	public void code() {
		System.out.println("猪不需要打代码") ;
	}
}
public class JavaDemo {
	public static void main (String args []) {
		Action robotAction = new Robot ();
		Action personAction =new Person ();
		Action pigAction = new Pig ();

		System.out,println("********机器人行为*******");
		robotAction.command(Action.SLEEP);
		robotAction.command(Action.WORK);
		robotAction.command(Action.CODE);
		System.out,println("********人行为*******");
		personAction.command(Action.SLEEP);
		personAction.command(Action.WORK);
		personAction.command(Action.CODE);
		System.out,println("********猪行为*******");
		pigAction.command(Action.SLEEP);
		pigAction.command(Action.WORK);
		pigAction.command(Action.CODE);
	}
}