JAVA 抽象类&接口（一）_抽象类和接口中只有方法名,没有方法体的实现方法叫做?

1.抽象与接口

2回顾一下面向对象

• 抽象，将现实中的事物抽取出事物的属性和方法，封装成对象，通过对象的实例化和调用，完成需求。
  Student stu = new Student();

• 封装，隐藏类的内部细节，提供外部访问的接口。
  将多次重复运行的代码，封装到方法中，较少代码代码的冗余，提高代码的重用性。
  private int a = 10;
  public int getA(){}
  public void setA(int a){}

• 继承，子类继承父类中的共有属性和方法。关键字是extends。
  充分体现了java对象重用的特性，继承属性，重写方法。提高了代码的重用性。
  class a extends b

• 多态，一种类型，多种形态。父类对象在编译器是父类形态，运行期是子类形态。
  提高了java系统的可插拔性。
  Pet pet;// 父类类型。
  pet = new Penguin(“qq”,2,85,50,“雌”);
  pet = new Dog(“大黄”,3,75,85,“黄色”);

3.抽象类

• 1 .什么是抽象类？
  abstract 修饰的类叫做抽象类。
• 2.什么是抽象方法？
  使用abstract修饰的方法叫做抽象方法，抽象方法不能有具体的实现，子类必须重写。

3.1 特征

1. abstract 修饰的类是抽象类：

• 1： 抽象类不能实例化。
• 2: 抽象类中有抽象方法，子类必须重写。
• 3: 抽象类中可以有非抽象方法，不要求子类强制实现。
• 4：如果一个类中，有抽象方法，那么这个类一定是抽象类。
• 5： 如果一个类是抽象类，这个类中一定有抽象方法吗？不一定。

下面展示一些 宠物父类 抽象类代码片。

public abstract class Pet {

	private String name;
	private int age;
	private int health;
	private int love;


public String getName() {
	return name;
}
public void setName(String name) {
	this.name = name;
}
public int getAge() {
	return age;
}
public void setAge(int age) {
	this.age = age;
}
public int getHealth() {
	return health;
}
public void setHealth(int health) {
	this.health = health;
}
public int getLove() {
	return love;
}
public void setLove(int love) {
	this.love = love;
}
public Pet() {
	super();
}
public Pet(String name, int age,  int health, int love) {
	super();
	this.name = name;
	this.age = age;
	this.health = health;
	this.love = love;
}

// 抽象类中有抽象方法。
public abstract void eat();

// 非抽象方法。
public void show(){
	
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

4. 接口

什么是接口？
接口不是类，interface修饰 一种数据类型。

• 1.Java为什么需要接口
• 通过接口实现多继承
• 用于实现耦合
• 如下图所示，一个类扩展了另一个类，一个接口扩展了另一个接口，一个类实现了一个接口。

链接: link.

4.1 接口的特点

1. 就像一个类一样，一个接口也能够拥有方法和属性，但是在接口中声明的方法默认是抽象的。（即只有方法标识符，而没有方法体）。

如果一个类实现了一个接口中要求的所有的方法，然而没有提供方法体而仅仅只有方法标识，那么这个类一定是一个抽象类。（必须记住：抽象方法只能存在于抽象类或者接口中，但抽象类中却能存在非抽象方法，即有方法体的方法。接口是百分之百的抽象类）。

——————————————————————

2. 接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。

• 除非实现接口的类是抽象类，否则该类要定义接口中的所有方法。
• 接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。另外，在 Java 中，接口类型可用来声明一个变量，他们可以成为一个空指针，或是被绑定在一个以此接口实现的对象。

---

4.2 代码

下面展示一些 普通类代码片。

	public class ABDemo implements AInterface,BInterface{

@Override
public void b() {
	// TODO Auto-generated method stub
	
}

@Override
public void a() {
	// TODO Auto-generated method stub
	
	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

下面展示一些 A接口代码片。

public interface AInterface {

// 方法。
public void a();

}
1
2
3
4
5
6

下面展示一些 B接口代码片。

	public interface BInterface {

// 方法。
public void b();

}
1
2
3
4
5
6

下面展示一些 final 代码片。l

注意：！！！！

• final : 最终的。不可改变的。

• final 修饰变量。表示常量，值不能再次赋值。常量要求全部大写。

• final 修饰方法。表示方法不能被重写。

• final 修饰类。表示类不能被继承。

• final 修饰对象，当前对象不能再new实例。

• String 就是被final修饰的类，不能被继承。

   public class FinalTest {
  
   public static void main(String[] args) {
   // 声明变量
   int a = 10;// a 表示变量。
   String b = "hello";
   
   // 常量
   final int AGEAVGSUM = 30;
   //		C = 35;// 使用final修饰的变量为常量，不能修改。
   
   
   
   // final修饰对象会怎么样。
   final Demo demo = new Demo();
   //		  demo = new Demo();// 错误，被final修饰的对象不能再new实例。
   demo.a = 30;
   System.out.println(demo.a);
   }
  
   }
   // 普通类 父类。
    class Demo{// final修饰的类不可以有子类。
  
    int a = 20;// 注意这个变量。
  
   public final void show(){// 这个方法不能被重写。
   
   }
   
   }
   // 子类
   class DemoChild extends Demo{
   //	@Override
   //	public void show() {// 错误，此方法在父类中被final修饰，表示不能被重写。
   //		// TODO Auto-generated method stub
   //		super.show();
   //	}
  
   }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27
  28
  29
  30
  31
  32
  33
  34
  35
  36
  37
  38
  39
  40

• 其中注意的·！！！

子类
class DemoChild extends Demo{
// @Override
// public void show() {// 错误，此方法在父类中被final修饰，表示不能被重写。
// // TODO Auto-generated method stub
// super.show();

——————————————————
JAVA 抽象类，接口第一篇概括如上，希望有能get到的点！！！