这孩子叫逆

java练习之abstract （抽象） final（最终） static（静态）练习

1：分析总结：写出private、abstract、static、final之间能否联动使用，并写出分析原因

private static final 之间可以任意结合

abstract 不可以与private static final 结合使用

2：关于三个修饰符描述不正确的是(AD)

A. static 可以修饰所有类型的变量不可以修饰局部变量，局部变量作用范围小，不是类变量

B. static 可以修饰方法

C. final 可以修饰类

D. abstract 可以修饰类、方法、属性不能修饰属性

3：下面关于 static 描述不正确的是(CD)

A. static 修饰的属性称为静态变量，被所有的对象共享

B. static 修饰的方法，可以直接用类名.方法名(参数)调用

C. static 修饰的方法中可以直接访问本类的其他方法非静态元素不能被静态元素调用

D. 父类中定义了 static 修饰的方法，子类中不能再定义同名的 static 方法

可以定义但是不是重写，多态中父类对象调用的还是父类中的方法

4：关于 final 描述错误的是(AB)

A. final 修饰的类是作用范围内常量，只允许一次赋值作用范围是地址，地址不可更改，内容可以改

B. final 修饰的方法不能被继承可以被继承，但不能被重写

C. final 修饰的方法不允许被覆盖

D. final 修饰的类没有子类

5：关于 abstract，以下选项正确的是：ABC

A. abstract 类中可以没有 abstract 方法

B. abstract 类的子类也可以是 abstract 类

C. abstract 类不能创建对象，但可以声明引用

D. abstract 方法不能有方法体

6：仔细阅读以下程序，写出程序输出的结果。

300 200 300 400

7：仔细阅读以下程序，选出哪些代码会导致程序出错()

A. //1 B. //2 C. //3 D. //4

E. //5 F. //6 G. //7 H. //8

8：仔细阅读以下程序，写出程序运行输出的结果。

In Static

MyClass()

MyClass(int)

9：仔细阅读以下代码，关于代码描述正确的是()

A. 编译通过，输出 10

B. 编译不通过，把第 2 行改为 final int value = 10;

C. 编译不通过，把第 3 行改为 public MyClass(){ value = 10; }

D. 以上描述都不正确

10：仔细阅读以下代码，关于以下程序描述正确的是()

A. 编译不通过

B. 编译通过；在//1 处加上：mv.value = 200; 则编译不通过

C. 编译通过。如果在//1 处加上：mv = new MyValue(); 则编译不通过

D. 以上描述都不正确

11：仔细阅读以下代码，选出正确选项()

A. 编译通过 B. //1 出错 C. //2 出错

D. //3 出错 E. //4 出错

12：仔细阅读以下代码，代码中哪些内容是错误的()

//1 B. //2 方法体 C. //3 方法重写权限修饰符只会等于或更大 D. //4

13：仔细阅读以下代码，程序是否能编译通过？如果可以，输出运行结果；如果不可以，应该怎样修改？

可以

m1() in super

m1(int) in sub

m1(double) in sub

14：仔细阅读以下程序，写出程序运行输出的结果。

m1 in Super

m2 in Sub

m1 in Sub

m2 in Sub

15：下面关于方法声明正确的是(E)

A. abstract final void m()

B. public void final m()

C. static abstract void m()

D. private abstract void m()

E. public static final void m()

16：判断以下描述是否正确，正确填 T；否则填 F。

(1) abstract 可以修饰类、方法、属性（F）

(2) 抽象类中不一定有构造方法（F）有，但是不能实例化

(3) 抽象类只能声明引用，不允许单独 new 对象（T）

(4) 所有类中都可以定义抽象方法（F）抽象方法必须在抽象类中

(5) 子类继承抽象类必须实现抽象类中所有抽象方法（T）

(6) static 可以修饰属性、方法、代码块（T）

(7) 静态属性只能用类名.静态属性名访问（T）

(8) 静态方法可以被本类中的其他方法直接访问（T）

(9) 静态代码块在创建对象时完成静态属性的初始化工作（F）类加载时

(10)final 只能修饰属性、方法、类（F）局部变量

(11)final 修饰的方法不能被继承（F）

(12)final 修饰的类不能被继承，即没有子类（T）

17：把三大特性中的形状类改为抽象类，并把其中的求周长和求面积的方法改为抽象方法。

package com.by.homework3.figure;

public abstract class Figure {
    public abstract void qiuzhouchang();
    public abstract void qiumianji();
}



package com.by.homework3.figure;

public class Circle extends Figure{
    int banjin;

    public Circle(int banjin) {
        this.banjin = banjin;
    }

    @Override
    public void qiuzhouchang() {
        Double zhouchang=2*3.14*banjin;
        System.out.println("圆的周长："+zhouchang);
    }

    @Override
    public void qiumianji() {
        Double mianji=3.14*banjin*banjin;
        System.out.println("圆的面积："+mianji);
    }
}



package com.by.homework3.figure;

import com.by.homework3.figure.Figure;

public class Rect extends Figure {
     int chang;
     int kuan;

    public Rect() {
    }

    public Rect(int chang,int kuan) {
        this.chang = chang;
        this.kuan=kuan;
    }

    @Override
    public void qiuzhouchang() {
        int zhouchang=chang*2+kuan*2;
        System.out.println("矩形的周长为："+zhouchang);
    }

    @Override
    public void qiumianji() {
        int mianji=chang*kuan;
        System.out.println("矩形面积为："+mianji);
    }
}



package com.by.homework3.figure;

public class Square extends Figure{
    int bianchang;

    public Square(){

    }
    public Square(int bianchang) {
        this.bianchang = bianchang;
    }

    public void qiuzhouchang(){
        int zhouchang=bianchang*4;
        System.out.println("正方形的周长:"+zhouchang);
    }
    public void qiumianji(){
        int mianji=bianchang*bianchang;
        System.out.println("正方形的面积:"+mianji);
    }
}

18：设计一个类 MyClass，为 MyClass 增加一个 count 属性，用来统计总共创建了多少个对象。

定义一个静态的count属性，无论哪个对象调用这个属性，静态元素只看最后改的那个数

package com.by.homework5;

class MyClass {
    public static int count=0;
    public MyClass(){
        count++;
    }
}

public class MyClassTest{
    public static void main(String[]args){
        MyClass myClass=new MyClass();
        MyClass myClass1=new MyClass();
        MyClass myClass2=new MyClass();
        MyClass myClass3=new MyClass();
        System.out.println(myClass3.count);
    }
}

19：定义一个类是员工,员工有id和name属性,有一个方法是eat，调用eat输出吃饭,有一个抽象方法是work,不同的员工工作的内容不同,定义3个类,程序员, 老师,网管,分别调用work的时候输出
：”id为xx的name”写代码”,”讲课”,”拉网线”

package com.by.homework5;

abstract class Worker{
    private int id;
    private String name;

    public Worker() {
    }

    public Worker(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void eat(){
        System.out.println("吃饭方法");
    }
    public abstract void work();
}



class Programmer extends Worker{

    public Programmer() {
    }

    public Programmer(int id, String name) {
        super(id, name);
    }

    @Override
    public void eat() {
        super.eat();
    }

    @Override
    public void work() {
        System.out.println("写代码");
    }

}
class Teacher extends Worker{
    public Teacher() {
    }

    public Teacher(int id, String name) {
        super(id, name);
    }

    public void work(){
        System.out.println("讲课");
    }
}

class Management extends Worker{
    public Management() {
        super();
    }

    public Management(int id, String name) {
        super(id, name);
    }

    @Override
    public int getId() {
        return super.getId();
    }

    @Override
    public void setId(int id) {
        super.setId(id);
    }

    @Override
    public String getName() {
        return super.getName();
    }

    @Override
    public void setName(String name) {
        super.setName(name);
    }

    @Override
    public void eat() {
        super.eat();
    }

    @Override
    public void work() {
        System.out.println("拉网线");
    }
}


public class WorkerTest {
    public static void main(String[]args){
        Worker worker=new Programmer(111,"张三");
        System.out.println("id为"+worker.getId()+"的"+worker.getName());
        worker.work();
        Worker worker1=new Management(222,"李四");
        System.out.println("id为"+worker1.getId()+"的"+worker1.getName());
        worker1.work();
        Worker worker2=new Teacher(333,"王五");
        System.out.println("id为"+worker2.getId()+"的"+worker2.getName());
        worker2.work();
    }
}

20：代码填空

abstract Super{

void m();

void m2();

}

class Sub extends Super{

//1.

}

abstract Sub1 extends Super{

//2.

}

1：void m(){}

void m2(){}

2: void m();

void m2();

21：设计一个抽象类，并演示它的三级使用

抽象类 Teacher,有两个方法teach(),add(int a,int b)

抽象子类 MathTeacher,继承于Teacher类,有一个方法teachMath();

第三级类 RealMathTeacher,继承于MathTeacher，有两个方法TeachHightMath(),add(int a,int b);

在主函数中，声明Teacher类引用，并且调用add方法

package com.by.homework5;

abstract class Teacher1{
    public int a;
    public int b;
    public  void taech(){};
    public abstract void add(int a,int b);
}



abstract class MathTeacher extends Teacher1{
    public  void teachMath(){};
}



class RealMathTeacher extends MathTeacher{
    public void teachHighMath(){
        System.out.println("教高数");
    }
    @Override
    public void add(int a, int b) {
        int sum=a+b;
        System.out.println("子类add方法"+sum);
    }
}



public class TeacherTest {
    public  static void main(String[]args){
        Teacher1 teacher1=new RealMathTeacher();
        RealMathTeacher r=(RealMathTeacher) teacher1;
        r.add(3,4);

    }

}

22：假如我们在开发一个系统时需要对员工类进行设计，员工包含3个属性，姓名、工号以及工资。

经理也是员工，除了含有员工的属性外，另外还有一个奖金属性。

请使用继承的思想设计出员工类和经理类。要求类中提供必要的方法进行属性访问。

分析：

普通员工类，

变量：姓名、工号以及工资

方法：工作

经理类：

变量：姓名、工号以及工资，奖金属性