Java中接口和抽象的区别有哪些?

Java基础面试题

一、接口和抽象的区别有哪些?

接口面试理论：

• 1.接口不可以被继承，不实例化，没有构造方法。

• 2.接口不可以定义普通方法和普通变量，只能定义抽象方法，

• 3.接口默认变量是用public,static,final修饰。

• 4.一个类要想实现接口必须实现接口里面的所有抽象方法。

• 5.Jdk1.8后可以定义静态成员变量，静态方法，可以定义默认的普通方法default

抽象类面试理论：

• 1.抽象类可以被继承，抽象类必须有abstract修饰，不可以被实例化，抽象类可以有普通方法和普通变量，

• 2.一个类要实现抽象类中的方法必须实现其所有的抽象方法，除非该方法被abstract修饰不能实现。

• 3.抽象类中可以有构造方法。

接口代码案例验证以上总结

1.创建接口类

/**
 * 接口
 * @author jkl
 *
 */
public interface UserService {
	
//	private String nameValue ="私有成员变量";   //接口不能定义私有的成员变量
//	public volatile String volatiles = "张三";  // 接口不能定义volatile关键字变量
//	public String nameValue  ;  //不能定义成员变量，如果定义则需要给其赋值 null 或"";
	public  String nameValue ="接口定义成员变量";
	public  String nameValue2 = null;
    public static String staticValue ="接口定义静态变量";
	public static final String FANAL_VALUE ="接口定义final成员变量";
	 
//  public  UserService(){}; //接口不能定义构造函数
	
	 //接口默认方法
	 default double sqrt(int a) {
		 System.out.println(a);
	    return Math.sqrt(a);
	}
	 
	 public default void getVoid(){
		 System.out.println("默认接口(无)返回值方法");
		 System.out.println(staticValue+"====静态成员变量");
	 }
	 public default String getReuslt(String name){
		 System.out.println("默认接口(有)返回值方法:"+name);
		 return name;
	 }
	 public default int  getInt(){
		 String strss = "hello java ";
		 System.out.println("int 数据类型");
		 return 0 ;
	 }
	 //抽象方法
	 abstract public void addPeople();
	 //普通接口方法
	 public void addUser(String name);
	 //普通接口方法
	 public void deleteUser();
	 
	/* 
	 * 不能定义默认的static静态普通方法。编译报错
	  public default static void getStatic (){
		 return null;
	 }*/

}

2.创建接口实现类

public class UserServiceImpl implements UserService{

	@Override
	public void addUser(String name) {
		System.out.println(name+"添加用户");
		
	}

	@Override
	public void deleteUser() {
		System.out.println("删除用户");
	}

	@Override
	public void addPeople() {
		System.out.println("添加人民");
	}

}

3.测试接口的执行

/**
 *接口interface 
 * @author jkl
 *
 */
public class TestInter {
	public static void main(String[] args) {
//		UserService users = new UserService();// 接口不能实例化new,
		UserService user = new UserServiceImpl();
		user.getReuslt("张三");
		user.addUser("接口普通方法：");
		user.addPeople();
		System.out.println("************************");
		UserEntexds u = new UserEntexds();
		
		u.addUsers("继承后出入新数据：");
		u.addPeople();
	}

}

4.输出结果

默认接口(有)返回值方法:张三
接口普通方法：添加用户
添加人民
************************
继承后出入新数据：添加用户
添加人民

5.接口的实现类可以被继承

接口是不可以被继承，但接口的实现类是可以被继承的

/**
 * 接口是不可以被继承，但接口的实现类是可以被继承的
 * @author jkl
 *
 */
public class UserEntexds extends UserServiceImpl{
	
	public void addUsers(String name){
		this.addUser(name);
	}

}

接口不能被继承

抽象类码案例验证以上总结

1.创建抽象类

/**
 * 抽象类
 * @author jkl
 *
 */
public abstract class  PeopleService {
	
	private String name ="张三";//成员变量
	private static String userName;//静态成员变量
	private final static String VALUE_NAME ="valueName";//final成员变量:值不可被修改
	private volatile String volatiles = "张三"; // volatile关键字变量:值可以修改

	public PeopleService(){
		
	}
	/**
	 * 有参构造函数
	 * 被static和final关键字修饰的变量不能添加到构造函数中
	 */
	public PeopleService(String name, String volatiles) {
		super();
		this.name = name;
		this.volatiles = volatiles;
	}

	//抽象方法-1
	abstract public void addPeople();
	//抽象方法-2
	public abstract void deletePeople();
	
//	public void updateStatus(); //抽象类中不能定义抽象
	
	//普通方法
	public void updatePeople(String id){
		System.out.println("修改用户"+id);
	}
	//普通方法
	public void queryPeople(String id){
		System.out.println("查询所有用户"+id);
	}
	
}

2.创建抽象类的继承类

/**
 * 抽象类只能被继承,不能被实现
 * @author jkl
 *
 */
public class PeopleServiceImpl extends PeopleService{

	@Override
	public void addPeople() {
		System.out.println("添加用户");
	}

	@Override
	public void deletePeople() {
		System.out.println("删除用户");
	}
	
	public void update(String id){
		this.updatePeople(id);//抽象类修改方
	}
	
	public void getAll(String id){
		this.queryPeople(id);//抽象类修改方
	}

}

抽象类不能被实现，实现会报错如下

3.测试抽象接口

/**
 * 测试抽象接口
 * @author jkl
 *
 */
public class TestAbstrct {

	public static void main(String[] args) {
//		PeopleService p1 = new PeopleService(); // 抽象类不能实例化new,
		//只能调用抽象方法的接口
		PeopleService p2 = new PeopleServiceImpl();
		p2.addPeople();
		p2.deletePeople();
		p2.queryPeople("1");
		p2.updatePeople("1");
        
		System.out.println("=========================");
		//既能调抽象类的接口，自身的接口也可以调用
		PeopleServiceImpl p3 = new PeopleServiceImpl();
		p3.addPeople();
		p3.deletePeople();
		p3.queryPeople("2");
		p3.updatePeople("2");
		p3.update("3");
		p3.getAll("3");
	}
}

4.输出结果

添加用户
删除用户
查询所有用户1
修改用户1
=========================
添加用户
删除用户
查询所有用户2
修改用户2
修改用户3
查询所有用户3