抽象类,接口学习笔记----Java

抽象类

抽象方法

1. 抽象:抽取相同的获取相似的代码;
2. 抽象方法:只有方法的声明,没有方法的具体实现;
3. 抽象方法的语法:

        访问修饰符  abstract 返回值类型 方法的名称(方法的参数);

4. 注意事项:
5. 定义抽象方法:

抽象类

1. 也就是定义一个抽象类,因为是抽象概念,不能被实例化;
2. 抽象类定义语法:

       访问修饰符 abstract class  类名{}

3. 抽象类的特点:
   (1)抽象类与抽象方法都必须有abstract关键字来修饰;
   (2)抽象方法必须在抽象类中,抽象类中可以有抽象方法也可以有普通方法;
   (3)抽象类不可以被实例化;
   (4)如果抽象类是父类子类必须实现父类中的所有抽象方法,子类实现父类的抽象方法时,就是一个普通的方法,都有方法体;子类也是抽象类的时候不需要实现父类的抽象方法;
   (5)抽象类不能被实例化,所以一般抽象类是父类,用于给子类进行方法的重写
4. 抽象方法的使用场景: 在父类中这个方法没有具体实现,写成普通方法也是多余的,父类只是为了给子类进行重写的时候就使用抽象方法; ==>因为抽象方法都在抽象类里,所以抽象类必须存在;
5. 案例代码:

package abstractText;
//父类,抽象类
public abstract class Emp {
	private String name;
	private String noid;
	private double salary;
	
	//抽象方法
	public abstract void work();
}

package abstractText;
//子类继承,重写抽象方法
public class Developer extends Emp{
	private double prize;
	@Override
	public void work() {
		System.out.println("写代码");
		
	}

}

package abstractText;
//子类继承,重写抽象方法
public class Texter extends Emp{

	@Override
	public void work() {
		System.out.println("做测试");
		
	}

}

package abstractText;

public class TextAbstract {
	public static void main(String[] args) {
		//通过多态,进行实例化;
		Emp emp = new Developer();
		emp.work();
		Emp emp01 = new Texter();
		emp01.work();
	}
}

运行结果

抽象类中的成员

1. 抽象类中可以有成员变量,但是成员变量不能用抽象进行修饰;
2. 抽象类中可以有构造方法,抽象类的构造方法一般是用于给子类进行调用,对其进行赋值,因为抽象类不能实例化,所以不能给成员变量进行赋值,只能借助于子类;
3. 抽象类中可以有方法
   抽象方法 ==> 子类必须重写
   普通方法 ==> 一般也是给子类进行重写,只是没有强制要求;

接口

1. 开发中接口本质是定义一些规范或者约束,通俗的说其实就是在类中定义了一些抽象的方法;
2. 使用接口的好处:
   (1)对接口的实现类进行约束;
   (2)实现了方法的声明与具体的实现进行分离,代码结构更加清晰,降低代码耦合度;
3. 接口的特点 :
   (1)接口定义的关键字 interface 可以看做一个类(在编译后也是一个class文件);
   (2)接口定义:

语法:
访问修饰符 interface 接口名称{ }

注:class 与 interface 只能存在一个
接口中方法都是抽象方法
在接口中定义的方法如果没有加上 abstract 关键字会默认加上abstract关键字
在JDK1.8以后接口里支持静态方法
接口不能被实例化
定义接口之后一般会存在实现类

4. 接口的实现类:

语法: public class 类名 implements 定义的接口1 , 定义的接口2{}

(2)接口的实现类,实现接口中的所有的抽象方法(不包含静态方法)
(3)Java中继承只能有一个父类,Java实现接口可以实现多个接口,就是解决java中单继承的问题;

5. 调用接口的方法
   (1)通过具体实现类来调用
   (2)接口中定义的静态方法,必须通过接口名字.方法来进行调用,不能实例化对象来进行调用;

接口成员

1. 接口中没有变量,只有常量,默认 用 public static final 进行修饰;
2. 接口中的常量,必须在声明的时候就给其赋值;
3. 常量命名全部大写单词之间用_连接;
4. 接口中没有构造方法,因为构造方法是实例化对象或者给成员变量进行赋值,接口不能实例化且没有变量,所以不需要构造方法;
5. 接口中必须都是抽象方法,但是在jdk1.8以后可以存在静态方法,静态方法只能通过接口名称调用;

类与类 接口与类 接口与接口之间的关系

类与类之间的关系

Java中只支持单继承的关系 A继承B;

类与接口之间的关系

类可以实现接口,可以实现一个或多个接口 ==>解决Java单继承的关系;

接口与接口之间的关系

接口与接口有继承关系,接口与接口可以多继承;如果接口继承接口,实现类实现这个接口,必须实现继承中的所有抽象方法;

抽象类与接口

1. 相同点:都不能实例化; 都可以来定义抽象方法; 接口与抽象类中的方法都是为了给子类进行重写;
2. 不同点:接口可以多继承,抽象类不可以多继承; 接口中所有的方法都必须是抽象方法,抽象类中可以有普通方法也可以有抽象方法; 抽象类中可以有成员变量和构造方法,接口只可以是常量没有构造方法;

匿名内部类

1. 没有名字的内部类,就称为匿名内部类;
2. 前提条件: 必须是抽象类 或者 必须是个接口;

         语法 :
  		      new  抽象类或者是接口(){
  				   实现的抽象方法
                }

4. 两种调用方式案例,

//接口定义
public interface Inner {
	
	   void show();
	   
	   String showInfo();

}

//抽象类定义
public  abstract class Inner1 {
	
	  public    abstract  void   show();
	   
	  public    abstract    String showInfo();

}

public class Test {
	public static void main(String[] args) {
	//接口调用方法一
		 new Thread(new Runnable() {
			
			@Override
			public void run() {
				 System.out.println("1111111");
			}
		}).start();
		
		//接口调用方法二
		Inner inner =  new Inner() {
		  
		 @Override public String showInfo() { return "哈哈"; }
		 
		 @Override public void show() { System.out.println("哈哈123"); }
		 
		 }
		 
		
		 System.out.println(inner.showInfo());
		 inner.show();
		
	}

}

public class Test1 {
	public static void main(String[] args) {
	//抽象类调用
	 String name = 	 new   Inner1() {
			
			@Override
			public String showInfo() {
				return "hhh";
			}
			
			@Override
			public void show() {
				 System.out.println("1111");
			}
		}.showInfo();
		System.out.println(name);
	}