abstract修饰符
1.语法
例子：
package day11;
public class TestShape {
public static void main(String[] args) {
Shape s1 = new Rect(4, 2);
Shape s2 = new Circle(5);
System.out.println(s1.area());
System.out.println(s1.girth());
System.out.println(s2.area());
System.out.println(s2.girth());
}
}
class Shape {
public double area() {
return 0.0;
}
public double girth() {
return 0.0;
}
}
class Rect extends Shape {
private double x, y;
public Rect(double x, double y) {
this.x = x;
this.y = y;
}
public double area() {
return x * y;
}
public double girth() {
return 2 * (x + y);
}
}
class Circle extends Shape {
private double r;
public Circle(double r) {
this.r = r;
}
public double area() {
return Math.PI * r * r;
}
public double girth() {
return 2 * Math.PI * r;
}
}
运行结果：
在下图代码中：
在代码里出现了问题：在Shape类里的area和girth方法里的返回值没有用，写了多余（得不到执行），但是不写却不行，因为有double类型的返回值。
#怎么解决？思路：用抽象方法。留给子类实现。‘’
抽象类：
应用：Abstract修饰类，此类不能new对象，因为抽象类是抽象的，无法对其实例化。
抽象类：可以声明引用，但是不能用来创建对象。
分析：吃方法是抽象的，只有声明，没有实现。
抽象方法：只有声明 没有实现，实现用;取代。
父类无实现，是抽象方法，子类去实现（这也是一种特殊的覆盖）。
实现也是一种覆盖，要遵循覆盖的原理。
代码：
package day11;
/*
*
Animal仅仅是一种会吃会睡的对象，再无其他行为，不够具体、不够完整。
程序是用来模拟现实世界、解决实际问题的，现实世界中存在的都是“动物”具体的子类对象，
并不存在“动物”对象，所以，Animal不应该被独立创建成对象。==》抽象类
*/
public class TestAbstract {
public static void main(String[] args) {
Animal a;//声明
a = new Dog();
a.eat();
}
}
abstract class Animal {
public abstract void eat();
public void sleep() {
System.out.println("动物在睡...");
}
}
class Dog extends Animal{
public void eat() {
System.out.println("Dog eat bone");
}
}
运行结果：（子类实现了父类抽象的吃方法）
总结：
1.类是对象的模板，是对象的图纸。模板没有创建完，还不能去创建对象，如果有抽象方法的话，必须是抽象类。（如果一个类拥有抽象方法，这个类必须是抽象类）
2.抽象类未必有抽象方法。
3.只有抽象类才能继承抽象类。
4.子类继承一个抽象类，如果子类不希望也称为抽象类，就必须实现父类中所有的抽象方法。（父类声明对象，子类引用对象）
package day11;
public class TestShape {
public static void main(String[] args) {Shape s1 = new Rect(4, 2);Shape s2 = new Circle(5);System.out.println(s1.area());System.out.println(s1.girth());System.out.println(s2.area());System.out.println(s2.girth());}
}
class Shape {public double area() {return 0.0;}
public double girth() {return 0.0;}
}
class Rect extends Shape {private double x, y;
public Rect(double x, double y) {this.x = x;this.y = y;}
public double area() {return x * y;}
public double girth() {return 2 * (x + y);}}
class Circle extends Shape {private double r;
public Circle(double r) {this.r = r;}
public double area() {return Math.PI * r * r;}
public double girth() {return 2 * Math.PI * r;}}
2.abstract设计思想
抽象类只能声明引用，不能创建对象。简而言之，抽象类没有对象。抽象方法只有声明没有实现。抽象方法定义了能做什么，实现定义了怎么做。（声明在父类，实现在子类）
构造方法是不能继承，所以谈不上覆盖，因此不可能是抽象方法。
私有方法是不能继承，所以谈不上覆盖，因此不可能是抽象方法。
抽象关键字不能和private一起使用。
3.扩展-抽象类是否拥有对象？
有对象，但不能new对象
代码：
package day12;
public class testAbstract {
public static void main(String[] args) {
// A a = new A();//抽象类不能new对象，但是不代表它没有对象
A1 a = new B1();
a.print();
}
}
abstract class A1 {
int m = 10;
public void print() {
System.out.println(this.m);
}
}
class B1 extends A1 {
}
运行结果：（抽象类的对象独立存在，所以不能new对象）
4.