Java抽象类与接口一篇搞懂

最新推荐文章于 2023-09-26 10:17:34 发布

夏至青柠

最新推荐文章于 2023-09-26 10:17:34 发布

阅读量75

点赞数 1

分类专栏： 21天学习Java基础文章标签：上转型对象及其特征抽象类接口接口回调抽象类与接口区别

本文链接：https://blog.csdn.net/qibulemingzi/article/details/126246196

版权

21天学习Java基础专栏收录该内容

14 篇文章 2 订阅

订阅专栏

活动地址：CSDN21天学习挑战赛

一、上转型对象及其特征

上转型对象：
子类对象赋值给父类变量
上转型对象是可以调用被子类继承的变量和方法，不能调用子类自己创建的变量和方法。
上转型对象不能调用子类自己创建的变量和方法，如果需要强制使用就需要将上转型对象类型强制转换成子类对象。
例如：

package com.wangxing.test1;
//父类
public class Person {
	public  void  testPerson() {
		System.out.println("父类Person的实例方法");
	}
}

package com.wangxing.test1;
//子类
public class Student extends Person{
	public  void  testStudent() {
		System.out.println("子类Student的实例方法");
	}
}

package com.wangxing.test1;

public class Test1 {
	public static void main(String[] args) {
		//上转型对象---子类对象赋值给父类变量。
		//person上转型对象表示将子类对象向上转型成父类对象
		Person  person=new Student(); //person上转型对象
		//上转型对象的可以调用被子类继承的变量和方法，不能调用子类自己创建的变量和方法。
		person.testPerson();
		//person.testStudent();
		//上转型对象不能调用子类自己创建的变量和方法，那么如果一定要强制使用子类自己创建的变量和方法，此时我们需要将上转型对象强制类型转换成子类对象。
		Student stu=(Student)person;
		stu.testStudent();
	}
}

运行结果：
在这里插入图片描述

二、抽象类

类：用来描述具有共同性质的一组事物的自定义复合数据类型
通过class关键字创建一个java类
抽象类：通过abstract关键字修饰的java类就是抽象类
格式：访问修饰符 abstract class 类名{}
例如：

public abstract class Hello{}

2.1为什么使用抽象类

抽象类的出现体现了java的重构。【重构是将重复的动作提取出来】
抽象类是提供可以由子类共享的一般形式，由子类根据自己实际情况去处理这个一般形式。
例如：
坐车收费。出租车有收费功能【一公里1元】。公交车有收费功能【全程1元】
抽象类的子类往往是同一种事物。

2.2抽象类中可以有哪些元素

抽象类中的元素—>实例变量、类变量、构造方法、实例方法、类方法、抽象方法。

2.2.1抽象方法

抽象方法: abstract修饰，没有方法体的方法。
抽象方法是抽象类提供给子类的一般形式
抽象类中可以有抽象方法，也可以没有抽象方法。
普通的java类是不能有抽象方法的。
例如：

package com.wangxing.test1;

public abstract  class MyAbstractClass {
	public  int  id=1001; //实例变量
	public static String  name="zhangsan"; //类变量
	public MyAbstractClass() {
		System.out.println("构造方法");
	}
	public  void  testMethod() {
		System.out.println("实例方法");
	}
	public static void  staticMethod() {
		System.out.println("类方法");
	}
	//abstract修饰，没有方法体的方法就是抽象方法
	//抽象方法就是抽象类提供给子类的一般形式
	//抽象类中可以有抽象方法，也可以一个抽象方法都没有
	public abstract  void  abstractMethod();
}

2.3抽象类的具体用法

（1）抽象类不能new
（2）普通的java类继承了抽象类，就需要重写抽象类中的抽象方法，或者将普通类改成抽象类
（3）抽象类可以继承其他抽象类，可以不用重写抽象方法
（4）利用上转型对象创建出抽象类方法
（5）抽象类对象可以访问抽象类中的实例变量、类变量、构造方法、实例方法、类方法、抽象方法
（6）抽象类对象访问抽象方法时候实际上访问的是子类重写以后的抽象方法。
（7）当某一个普通的java类中的方法参数是抽象类类型的时候，可以传递上转型对象，也可以是抽象类的子类对象。
例如：

package com.wangxing.test1;

public abstract  class MyAbstractClass {
	public  int  id=1001; //实例变量
	public static String  name="zhangsan"; //类变量
	
	public MyAbstractClass() {
		System.out.println("构造方法");
	}
	
	public  void  testMethod() {
		System.out.println("实例方法");
	}
	
	public static void  staticMethod() {
		System.out.println("类方法");
	}
	//abstract修饰，没有方法体的方法就是抽象方法
	//抽象方法就是抽象类提供给子类的一般形式
	//抽象类中可以有抽象方法，也可以一个抽象方法都没有
	public abstract  void  abstractMethod();	
}

package com.wangxing.test1;
//普通的java类继承了抽象类，就需要重写抽象类中的抽象方法，否则将这个普通的java类改成抽象类。
public  class SunClass extends MyAbstractClass{
	//子类重写抽象类的抽象方法
	//去掉abstract，加上方法体
	public void abstractMethod() {
		System.out.println("子类重写抽象类的抽象方法");
		
	}
}

package com.wangxing.test1;

public class MyClass {
	public  void  testMyClass(MyAbstractClass  mac) {
		
	}
}

package com.wangxing.test1;

public class Test1 {
	public static void main(String[] args) {
		//抽象类的具体用法
		//1.抽象类不能new
		//MyAbstractClass mac=new MyAbstractClass();
		//2.利用上转型对象创建出抽象类对象
		MyAbstractClass mac=new SunClass();
		System.out.println("id=="+mac.id);
		System.out.println("name=="+MyAbstractClass.name);
		System.out.println("name=="+mac.name);
		mac.testMethod();
		mac.staticMethod();
		//子类重写以后的抽象方发
		mac.abstractMethod();
		
		MyClass  mc=new MyClass();
		//当某一个普通的java类中的方法参数是抽象类类型的时候，可以传递上转型对象，也可以是抽象类的子类对象
		mc.testMyClass(mac);
		//抽象类的子类对象
		SunClass  sun=new SunClass();
		mc.testMyClass(sun);
	}
}

运行结果：

在这里插入图片描述

三、接口

接口：通过interface关键字修饰的java元素
例如：

package com.wangxing.test1;
//接口
public interface MyInterface {

}

3.1为什么使用接口

接口体现出java的扩展。【为了以后程序扩展方便】
接口是提供可以由子类共享的一般形式，由子类根据自己的实际情况去处理这个一般形式。
例如：
收费，出租车由收费功能【一公里1元】飞机由收费功能【全程1000元】

接口的子类往往都是不同种类事物
接口主要是提供功能，提供功能不去实现该功能，由不同种类事物去实现，可以被使用多个。

3.2接口中可以有哪些元素

接口中可以有类变量、类方法、抽象方法。
1.接口中变量一定是public static修饰的类变量，public static可以省略
2.接口中的类方法一定是public修饰的，public可以被省略。
3.接口中的抽象方法一定是public abstract修饰的，public abstract可以省略
例如：

package com.wangxing.test1;
//接口
public interface MyInterface {
	//接口中的变量一定是 public static修饰的类变量
	// public static是可以省略
	public  int  id=1001; //类变量
	int age=23;
	public static String  name="lisi"; //类变量
	//接口中没有构造方法
	//public  MyInterface() {}
	//接口中没有实例方法
	//public  void  testMethod() {}
	//接口中的类方法一定是public修饰的，public可以被省略
	public static void  staticMethod() {}
	//接口中的抽象方法一定是public  abstract修饰的
	//public  abstract可以省略
	public  abstract void abstractMethod1();
	abstract void abstractMethod2();
	void abstractMethod3();
}

3.3接口的具体用法

（1）接口不能被new
（2）类可以通过implements关键字去实现一个/多个接口
实现一个public class MyClass implements MyInterface{}
实现多个接口public class MyClass implements MyInterface1,MyInterface2,…,MyInterfacen{}
（3）普通的类去实现一个/多个接口，就需要将每一个接口中的抽象方法重写，否则就需要将这个普通的类改成抽象类。
（4）抽象类去实现一个/多个接口，不需要重写接口中的抽象方法。
（5）接口可以继承接口，并且可以继承父接口中的所有元素。

package com.wangxing.test1;
//接口可以继承接口，并且可以继承父接口中的所有元素
public interface DemoInterface extends MyInterface{

}

（6）利用接口回调对象创建出接口对象
（7）当某一个普通的java类中的方法参数是接口类型的时候，可以传递接口回调对象，也可以是接口的子类对象。
例如：

package com.wangxing.test1;
//接口
public interface MyInterface {
	//接口中的变量一定是 public static修饰的类变量
	// public static是可以省略
	public  int  id=1001; //类变量
	int age=23;
	public static String  name="lisi"; //类变量
	//接口中没有构造方法
	//public  MyInterface() {}
	//接口中没有实例方法
	//public  void  testMethod() {}
	//接口中的类方法一定是public修饰的，public可以被省略
	public static void  staticMethod() {
		System.out.println("接口中的类方法");
	}
	//接口中的抽象方法一定是public  abstract修饰的
	//public  abstract可以省略
	public  abstract void abstractMethod1();
	abstract void abstractMethod2();
	void abstractMethod3();
}

package com.wangxing.test1;
//类可以通过implements关键字去实现一个/多个接口
//普通的类去实现一个/多个接口，就需要将每一个接口中的抽象方法重写，否则就需要将这个普通的类改成抽象类
public class MyClass implements MyInterface{

	public void abstractMethod1() {
		System.out.println("子类重写抽象类的抽象方法");
	}

	public void abstractMethod2() {
		// TODO Auto-generated method stub
	}

	public void abstractMethod3() {
		// TODO Auto-generated method stub
	}
}

package com.wangxing.test1;

public class DoClass {
   public  void  test(MyInterface inter) {  
   }
}

package com.wangxing.test1;
public class Test1 {
	public static void main(String[] args) {
		//1.接口不能new
		//new MyInterface();
		MyInterface inter1=new MyClass();
		System.out.println(inter1.name);
		MyInterface.staticMethod();
		inter1.abstractMethod1();
		
		DoClass  dc=new DoClass();
		dc.test(inter1);
		MyClass  mc=new MyClass();
		dc.test(mc);
	}
}

运行结果：

在这里插入图片描述

四、抽象类与接口的区别

抽象类	接口
定义abstract class	定义interface
extends 只能继承一个类	implments 可以实现一个/多个接口
实例变量、类变量、构造方法、实例方法、类方法、【抽象方法】	只能有类变量、类方法、抽象方法
关键字不能省略	public、static 、abstract关键字可以省略

五、什么是接口回调对象及其基本特征

接口回调对象与上转型对象很相似
上转型对象—>子类对象赋值给父类变量
接口回调对象—>实现了该接口的子类对象赋值给接口变量。
接口回调对象可以调用被子类重写的抽象方法，但是不能调用子类自己的定义的变量和方法，如果一定要调用子类自己的定义的变量和方法，那么就需要将接口回调对象强制类型转换成子类对象
例如：

package com.wangxing.test1;
public interface TestInterface {
	void testMethod();
}

package com.wangxing.test1;
public class SunClass implements TestInterface{
	public  void  sunMethod() {
		System.out.println("SunClass类的实例方法");
	}
	@Override
	public void testMethod() {
		System.out.println("子类重写接口的抽象方法");
	}
}

package com.wangxing.test1;
public class Test1 {
	public static void main(String[] args) {
		//接口回调对象---实现了该接口的子类对象赋值给接口变量。
		TestInterface  inter1=new SunClass();
		//接口回调对象可以调用被子类重写的抽象方法，但是不能调用子类自己的定义的变量和方法
		inter1.testMethod();
		//inter1.sunMethod();
		//如果一定要调用子类自己的定义的变量和方法，那么就需要将接口回调对象强制类型转换成子类对象
		SunClass sc=(SunClass)inter1;
		sc.sunMethod();
	}
}

运行结果：
在这里插入图片描述

六、static \ this \ super \ final 关键字的用法

static —> 静态的【提前分配内存】
修饰的变量就是静态成员变量【类变量】，可以用类名访问，也可以用对象访问。
修饰的方法就是静态方法量【类方法】，可以用类名访问，也可以用对象访问。
this—>本类对象【出现在哪一个类中就表示哪一个类的对象】
本类中调用本类的实例变量\类变量\实例方法\类方法，可以省略
this是不能出现在静态方法中
super—>子类中表示父类对象
子类中访问父类构造方法“super([参数])”。
子类中访问父类的实例方法/实例变量”super.实例变量/实例方法”。
final—>最终的
final修饰的变量不能被重新赋值。
fianl修饰的静态成员变量叫静态常量。【静态常量全字母大写】
例如: public final static String TEXT=“java”;
final修饰的方法不能被重写。
final修饰的类不能被继承，没有子类。
例如：

package com.wangxing.test1;
//final修饰的类不能被继承，没有子类。
//public final class TestClass {
public class TestClass {
	public final String  name="zhangsan";
	public final void info() {
		System.out.println("父类TestClass类的实例方法");
	}
}

package com.wangxing.test1;
public class MyClass extends TestClass{
	
	//final修饰的方法不能被重写
	/*
	public  void info() {
		System.out.println("子类重写父类的方法");
	}
	*/
}

package com.wangxing.test1;
public class Test1 {
	public static void main(String[] args) {
		TestClass tc=new TestClass();
		System.out.println("name=="+tc.name);
		//final修饰的变量不能被重新赋值
		//tc.name="lisi";
		System.out.println("name=="+tc.name);
		tc.info();
		MyClass  mc=new MyClass();
		mc.info();
	}
}

运行结果：

在这里插入图片描述

总结

在这里插入图片描述

夏至青柠

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java抽象类与接口一篇搞懂

上转型对象：子类对象赋值给父类变量上转型对象是可以调用被子类继承的变量和方法，不能调用子类自己创建的变量和方法。上转型对象不能调用子类自己创建的变量和方法，如果需要强制使用就需要将上转型对象类型强制转换成子类对象。......
复制链接

扫一扫