abstract能修饰什么java_java-abstract修饰符

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.