三个修饰符(static、abstract、final)

Java学习思维导图
1.（static属性）有如下代码，写出程序输出结果。

package com.qf.q7.t1;

class MyClass{
	static int a;
	int b;
}
public class TestMain {
	public static void main(String[] args) {
		MyClass mc1 = new MyClass();
		MyClass mc2 =new MyClass();
		mc1.a=100;
		mc1.b=200;
		mc2.a=300;
		mc2.b=400;
		System.out.println(mc1.a);//300
		System.out.println(mc1.b);//200
		System.out.println(mc2.a);//300
		System.out.println(mc2.b);//400
	}
}

2.(静态成员)有如下代码，哪些运行会编译出错？

package com.qf.q7.t2;

public class MyClass {
	int a;
	static int b;
	void fa() {}
	static void fb() {}
	public void m1() {
		System.out.println(a);//1
		System.out.println(b);//2
		fa();//3
		fb();//4
	}
	public static void m2() {
		System.out.println(a);//5
		System.out.println(b);//6
		fa();//7
		fb();//8
	}
}

//5 静态方法不能直接访问非静态成员
//7 fa()改为静态方法,静态方法中不能访问非静态方法

3.(静态成员)有如下代码，请写出该程序运行时输出的结果。

package com.qf.q7.t3;
class MyClass{
	static int count = 0;
	public MyClass() {
		count++;
		System.out.println(count);
	}
}
public class TestMain {
	public static void main(String[] args) {
		MyClass mc1 = new MyClass();
		MyClass mc2 = new MyClass();
		MyClass mc3 = new MyClass();
	}
}

 1
 2
 3

4.（静态初始化代码块）有如下代码，请写出该程序运行的结果。

package com.qf.q7.t4;
class MyClass{
	static int i = 10;
	static {
		i=20;
		System.out.println("In Static");
	}
	public MyClass() {
		System.out.println("MyClass()");
	}
	public MyClass(int i) {
		System.out.println("MyClass(int)");
		this.i=i;
	}
}
public class TestMain {
	public static void main(String[] args) {
		MyClass mc1 = new MyClass();
		System.out.println(mc1.i);
		MyClass mc2 = new MyClass(10);
		System.out.println(mc2.i);
	}
}

In Static
MyClass()
20
MyClass(int)
10

5.（静态方法）有以下代码，写出这个程序的运行结果。

package com.qf.q7.t5;
class Super{
	public static void m1() {
		System.out.println("m1 in Super");
	}
	public void m2() {
		System.out.println("m2 in Super");
	}
}
class Sub extends Super{
	public static void m1() {
		System.out.println("m1 in Sub");
	}
	public void m2() {
		System.out.println("m2 in Sub");
	}
}
public class TestMain {
	public static void main(String[] args) {
		Super sup = new Sub();
		sup.m1();
		sup.m2();
		Sub sub = (Sub)sup;
		sub.m1();
		sub.m2();
	}
}

m1 in Super
m2 in Sub
m1 in Sub
m2 in Sub

6.（static）以下哪些论述是正确的。
A.静态方法中不能调用非静态方法
B.非静态方法中不能调用静态方法
C.静态方法不能被覆盖
D.静态方法能够用类名直接调用
E.可以在不产生任何一个对象的情况下调用静态方法
F.静态方法里可以使用this

A C D E

7.（final属性的初始化）有如下代码选择正确答案：

A.编译通过，输出10
B.编译不通过，把第2行改为final int value =10；
C.编译不通过，把第3行改为public MyClass（）{value=10;}

package com.qf.q7.t7;

class MyClass{
	final int value;
	public MyClass(){}
	public MyClass(int value) {
		this.value = value;
	}
}

public class TestMain {
	public static void main(String[] args) {
		MyClass mc = new MyClass(10);
		System.out.println(mc.value);
	}
}

8.(final变量)有如下代码，选择正确答案

package com.qf.q7.t8;
class MyClass{
	public void printValue(final int value) {
		System.out.println(value);
	}
	public void changeValue(int value) {
		value = value*2;
		System.out.println(value);
	}
}
public class TestMain {
	public static void main(String[] args) {
		MyClass mc = new MyClass();
		int value = 5;
		final int fvalue =10;
		mc.printValue(value);//1
		mc.printValue(fvalue);//2
		mc.changeValue(value);//3
		mc.changeValue(fvalue);//4
	}
}

A.编译通过
B.//1出错
C.//2出错
D.//3出错
E.//4出错
A正确
编译结果：
5
10
10
20

9.（final修饰引用）有如下代码

package com.qf.q7.t9;
class MyValue{
	int value;
}
public class TestFinal {
	public static void main(String[] args) {
		final MyValue mv = new MyValue();
		mv.value =100;
		//1
		System.out.println(mv.value);
	}
}

下面说法正确的是：C
A.编译不通过
B.编译通过。在//1处加上：mv.value=200;则编译不通过
C.编译通过。如果在//1处加上：mv=new MyValue();则编译不通过

10.(final方法，方法覆盖)有如下代码

package com.qf.q7.t10;
class Super {
	public final void m1() {
		System.out.println("m1() in Super");
	}
	public void m1(int i) {
		System.out.println("m1(int)in Super");
	}
}
class Sub extends Super{
	public void m1(int i) {
		System.out.println("m1(int)in Sub");
	}
	public void m1(double d) {
		System.out.println("m1(double)in Sub");
	}
}
public class TestMain {
	public static void main(String[] args) {
		Sub s = new Sub();
		s.m1();
		s.m1(10);
		s.m1(1.5);
	}
}

以上程序是否能编译通过？如果可以，输出运行结果；如果不可以，应该怎样修改？
可以，运行结果为：
m1() in Super
m1(int)in Sub
m1(double)in Sub

11.（abstract、方法覆盖）以下代码，问：这段代码哪些地方错误?

package com.qf.q7.t11;

abstract class MyAbstractClass {
	public abstract void m1();//1
	abstract protected void m2() {}//2
}
class MySubClass extends MyAbstractClass{
	void m1() {}//3
	protected void m2() {}//4
}

//2错误，抽象方法不需要{}
//3错误需要重写父类的抽象方法

12.（abstract）关于abstract，以下选项正确的是：
A.abstract类中可以没有abstract方法
B.abstract类的子类也可以是abstract类
C.abstract类不能创建对象，但可以声明引用
D.abstract方法不能有方法体

ABCD

13.（修饰符综合）下列方法声明中正确的是：

A.abstract final void m()  
B.public void final m()
C.static abstract void m()
D.private final void m()
E.private abstract void m()
F.public static final void m()
D F正确
A abstract final 冲突
B void final位置反
C static abstract冲突
E private abstract冲突

14.(abstract)将Ch7中的Shape类改为抽象类，并把其中的求周长和求面积的方法改为抽象方法。

package com.qf.day13.shape;
abstract class Shape {
	double sum=0;
	double area=1;
	public Shape(){
	}
	public abstract double area() ;
	public abstract double girth();
}
class Circle extends Shape{//圆
	double a=3.1415926;
	private double radius;
	public Circle(double radius) {
		this.radius=radius;
	}
	public double getRadius() {
		return radius;
	}
	public void setRadius(double radius) {
		this.radius = radius;
	}
	public double area() {
		area=a*radius*radius;
		return area;
	}
	public double girth() {
		sum=2*a*radius;
		return sum;
	}
}
class Rect extends Shape{//矩形
	private double length;
	private double wide;
	public Rect() {
	}
	public double getLength() {
		return length;
	}
	public void setLength(double length) {
		this.length = length;
	}
	public double getWide() {
		return wide;
	}
	public void setWide(double wide) {
		this.wide = wide;
	}
	public Rect(double length, double wide) {
		this.length = length;
		this.wide = wide;
	}
	public double area() {
		area=this.length*this.wide;
		return area;
	}
	public double girth() {
		sum=2*(this.length+this.wide);
		return sum;
	}
}
class Square extends Rect{//正方形
	public Square(double length) {
		setLength(length);
	}
	
	public double area() {
		area=getLength()*getLength();
		return area;
	}
	public double girth() {
		sum=4*getLength();
		return sum;
	}
}

package com.qf.day13.shape;
public class TestShape {
	public static void main(String[] args) {
		Circle circle = new Circle(2.0);
		Rect rect = new Rect(4.0,5.0);
		Square square = new Square(4.0);
		Shape[] shapes =new Shape[3];
		shapes[0]=circle;
		shapes[1]=rect;
		shapes[2]=square;
		for(int i=0;i<shapes.length;i++) {
			System.out.println("周长为:"+shapes[i].girth()+"\t"+"面积为:"+shapes[i].area());
		}
	}
}

15.(static)设计一个类MyClass，为M有Class增加一个count属性，用来统计总共创建了多少个对象。

package com.qf.q7.t15;
public class TestClass {
	public static void main(String[] args) {
		MyClass c1 = new MyClass();
		MyClass c2 = new MyClass();
		MyClass c3 = new MyClass();
		System.out.println(MyClass.count);
	}
}
class MyClass{
	static int count=0;
	public MyClass(){
		count++;
	}
}

NULL_KUN

发布了14 篇原创文章 · 获赞 20 · 访问量 2398

私信关注

三个修饰符(static、abstract、final)

猜你喜欢