Объявление класса Quest

public class A{}

class Questextends A, Object{}

станет корректным ( классы A и Quest находятся в одном файле ), если:

76.1. убрать спецификатор public перед А;

76.2. добавить спецификатор public к Quest;

76.3. убрать после extends один из классов;

76.4. не указывать явно класс Object;

77. Истинные высказывания для кода:

class A {A(int i) {} } //1

class B extends A{} //2

77.1. компилятор пытается создать по умолчанию конструктор для класса A;

77.2. компилятор пытается создать по умолчанию конструктор для класса B;

77.3. ошибка во время компиляции в строке 1;

77.4. ошибка во время компиляции в строке 2;

78. Результат компиляции и выполнения кода из файла Quest.java:

public class Base{

Base() {

int i=1;

System.out.print(i);

}

}

public class Quest extends Base {

static int i;

public static void main(String[ ] args){

Quest ob =new Quest ();

System.out.print(i);

}

}

78.1. ошибка компиляции

78.2. 0

78.3. 10

78.4. 1

78.5. ошибка выполнения

79. Результат компиляции и выполнения кода ИЗ ФАЙЛОВ Base.java И Quest.java:

// Base.java

public class Base{

Base() {

int i=1;

System.out.print(i);

}

}

// Quest.java

public class Quest extends Base {

static int i;

public static void main(String[ ] args){

Quest ob =new Quest ();

System.out.print(i);

}

}

79.1. ошибка компиляции

79.2. 0

79.3. 10

79.4. 1

79.5. ошибка выполнения

80. Результат компиляции и выполнения кода:

class Q{

private void show(int i) {

System.out.println(“1”);

}

}

class Quest extends Q {

public void show(int i) {

System.out.println(“2”);

}

public static void main(String[ ] args){

Q ob =new Quest ();

int i = ‘1’; //1

ob.show(i);

}

}

80.1. ошибка компиляции: метод show() недоступен

80.2. ошибка времени выполнения: метод show() недоступен

80.3. ошибка компиляции: несовпадение типов в строке 1

80.4. 2

80.5. 1

81. Результат компиляции и выполнения кода:

class Q{

void mQ (int i) {

System.out.print(“mQ”+i);

}

}

class Quest extends Q {

public void mQ(int i) {

System.out.println(“mQuest”+i);

}

public void mP(int i) {

System.out.println(“mP”+i);

}

public static void main(String[ ] args){

Q ob =new Quest (); //1

ob.mQ(1); //2

ob.mP(1); //3

}

}

81.1. mQ1 mP1

81.2. mQuest1 mP1

81.3. ошибка компиляции в строке //1

81.4. ошибка компиляции в строке //2

81.5. ошибка компиляции в строке //3

82. для вывода на консоль строки «Конструктор А» в результате выполнения кода:

class A{

A (int i) {

System.out.print(“Конструктор А”); }

}

public class Quest extends A {

public static void main(String[ ] args){

Quest s = new Quest();

//1

}

public Quest() {

//2

}

public void show(){

//3

}

}

необходимо:

82.1. вместо //1 написать A(1)

82.2. вместо //1 написать super(1)

82.3. вместо //2 написать super(1)

82.4. вместо //2 написать A(1)

82.5. вместо //3 написать super(1)

83. Истинные высказывания:

83.1. класс может наследовать свойства и методы суперкласса, указанного после ключевого слова extends;

83.2. класс может включать множество интерфейсов, перечисленных через запятую после ключевого слова implements;

83.3. интерфейсы представляют собой абстрактные классы, содержащие только нереализованные методы;

________________________________________________________________________ гр.9 _

84. без ошибок скомпилируются коды:

84.1. import java.util.*

package First;

class My{/*тело класса*/ }

84.2. package mypack;

import java.util.*;

public class First {/*тело класса*/ }

84.3. /* комментарий*/

package first;

import java.util.*;

class First {/*тело класса*/ }

85. Результат компиляции и выполнения кода:

abstract class QuestBase{

static int i;

abstract void show();

}

public class Quest extends QuestBase {

public static void main(String[ ] args){

boolean [ ] a=new boolean[3];

for (i=0; i<a.length; i++)

System.out.print(“ “ + a[i]);

}

}

85.1. false false false

85.2. ошибка компиляции: массив а использован прежде, чем проинициализирован;

85.3. ошибка компиляции: Quest должен быть объявлен как abstract;

85.4. ошибка времени выполнения: будет сгенерировано исключение IndexOutOfBounds;

85.5. true true true

86. корректные определения интерфейса:

86.1. interface Myinterface{

public int result (int i) {return (i++);}}

86.2. interface Myinterface{

int result (int i);}

86.3. public interface Myinterface{

public static int result (int i);}

86.4. public interface Myinterface{

public final static int i;

{i=0;}

public abstract int result (int i);}

86.5. public interface Myinterface{

public final static int i;

public abstract int result (int i);}

87. Результат компиляции и выполнения кода
(классы находятся в разных пакетах):

package my;

class Q{

protected void method1(){

System.out.print(“1, “);}

public void method2(){

System.out.print(“2, “);}

private void method3(){

System.out.print(“3, “);}

void method4(){

System.out.print(“4, “);}

}

package my.other;

import my.*;

class Quest extends Q {

public static void main(String[ ] a){

Q ob =new Q ();

ob.method1(); //1

ob.method2(); //2

ob.method3(); //3

ob.method4(); //4

} }

87.1. 1, 2, 3, 4

87.2. ошибка компиляции в строке 1

87.3. ошибка компиляции в строке 2

87.4. ошибка компиляции в строке 3

87.5. ошибка компиляции в строке 4

88. не создадут ошибки при компиляции определения методов:

public interface Myinterface {

Error runtime(); //1

public Class show(); //2

protected int method(); //3

private String get(); //4

abstract void put (Byte Byte); //5

}

88.1. 1

88.2. 2

88.3. 3

88.4. 4

88.5. 5

89. Истинные высказывания:

89.1. абстрактные классы содержат только объявления абстрактных методов;

89.2. реализация абстрактных методов содержится, как правило, в подклассах;

89.3. объекты абстрактных классов создавать нельзя;

89.4. можно создавать объекты подклассов, реализующих абстрактные методы;

89.5. абстрактные классы могут содержать и полностью реализованные методы;

89.6. внутри интерфейса не может быть реализован ни один метод (это полностью абстрактный класс);

89.7. класс может реализовывать любое число интерфейсов;

89.8. в интерфейсах все объявленные методы автоматически трактуются как private;

90. Истинные высказывания:

90.1. класс может наследовать только один суперкласс;

90.2. в интерфейсах все объявленные методы автоматически трактуются как public и abstract;

90.3. в интерфейсах все атрибуты автоматически трактуются как public;

90.4. в интерфейсах все атрибуты автоматически трактуются как static;

90.5. в интерфейсах все атрибуты автоматически трактуются как final;

90.6. на множестве интерфейсов определена иерархия по наследованию;

90.7. иерархия по наследованию на множестве интерфейсов взаимосвязана с иерархией классов;

90.8. класс, расширяющий интерфейс, но реализующий не все его методы, должен быть объявлен как abstract;

90.9. класс, расширяющий интерфейс, но реализующий не все его методы, может не объявляться как abstract, если в программе не создаётся его экземпляров.

91. Истинные высказывания:

91.1. интерфейсы описываются аналогично абстрактным классам;

91.2. интерфейсы не могут иметь экземпляров;

91.3. интерфейсы не могут иметь полей данных;

91.4. интерфейсы не могут иметь констант;

91.5. интерфейсы не могут иметь реализации никаких своих методов;

91.6. интерфейс определяет методы, которые должны быть реализованы его классом-наследником

92. Истинные высказывания:

92.1. экземпляров типа интерфейс не бывает;

92.2. не могут существовать переменные типа интерфейс;

92.3. переменные типа интерфейс могут существовать как ссылочные переменные;

92.4. переменные типа интерфейс могут существовать как указатели;

92.5. с помощью переменной типа интерфейс можно вызывать только методы, декларированные в данном интерфейсе;

93. Истинные высказывания:

93.1. композиция – это описание объекта как состоящего из других объектов;

93.2. композиция позволяет объединять отдельные части в единую более сложную систему;

93.3. агрегация – это отношение включения объекта как составной части в более сложную систему;

93.4. ассоциация – это объединение независимых объектов;

93.5. наследование характеризуется отношением “is-a” (“это есть”, “является”);

93.6. композиция характеризуется отношением “has-a” (“имеет в своём составе”, “состоит из”) и “use-a” (“использует”).

93.7. сочетание множественного наследования интерфейсов и композиции – не есть альтернатива множественному наследованию классов;

_______________________________________________________________________ гр.10 _

94. Результат компиляции и выполнения кода:

abstract class A{

public int show(){return 1;}

}

class Quest {

static int i=2;

static A ob1 = new A() {

public int show(){return i++;}

};

static A ob2 = new A() {

public int show(){return ++i;}

};

public static void main(String[ ] args){

System.out.print(ob1.show());

System.out.print(ob2.show());

}

}

94.1. 34

94.2. 24

94.3. 33

94.4. 23

94.5. ошибка компиляции

Для класса

class Owner{

class Inner {

} }

корректны объявления:

95.1. new Owner.Inner();

95.2. Owner. new Inner();

95.3. new Owner. new Inner();

95.4. new Owner(). new Inner();

Дата добавления: 2015-10-29