周考二错题总结

程序中的对象就是现实生活中的对象 （x）

在现实生活中，对象是指客观世界的实体，在程序中，对象是通过一种抽象数据类型来描述的，这种抽象数据类型称为类，在程序中，对象是一组变量和相关方法的集合

public class A{…}
public class B extends A implements D {…}
public class C extends A {…}
public interface D {…}
变量a、b、c、d的定义如下：
A a = new A();  B b = new B();  
C c = new C();  D d = null;
则下列语句会有编译错误的是( D )。
​
A.   
a = b; 
B.   
d = b;  
C.   
d = (D)a; 
D.   
c = (C)b; 

类在强制类型转换过程中，如果是类转换成接口，那么类和接口之间没有继承关系，也可以转换，编译器不会报错。

Java中规定：在实例化子类对象时，必须先调用父类的构造方法，再调用子类的构造方法（先有父母再有孩子）。且必须在子类构造方法的第一行调用父类方法。

一个接口可以继承另外一个接口

interface a{}
interface b extends a{}

Java语言支持单继承

一个类同时实现一个接口再继承类

public class Cat implements Eat extends Annimals{}

下面各选项可以在A的子类中使用的是（A） class A { protected int method (int a, int b) { return 0; } } A. public int method (int a, int b) { return 0; } B. private int method(int a, int b) { return 0; } //访问修饰符要比父类高 C. private int method(int a, long b) { return 0; } //访问修饰符、参数列表 D. public short method(int a, int b) { return 0; } //返回值不一样

8.下列代码执行的结果是：

class Base{
    void test() { 
        System.out.println("Base.test()");
    }
}
public class Child extends Base {
    void test() {
        System.out.println("Child.test()");
    }
    public  static void main(String[] a) {
        Child anObj = new Child();
        Base baseObj = anObj;// 父类引用指向子类对象 本质还是子类
        baseObj.test();
    } 
}

结果： Child.test()

在本类中可以使用私有静态变量

String类是final类故不可以继承

interface中不可以有private、final方法

jdk1.8 default默认方法有方法实现

interface可以继承其他interface

父类中的私有成员变量，无法在子类中直接访问，通过getset方法访问

对象可以赋给所有类的祖先类

IFace o2 = new CFace();

IFace是接口，CFace是实现类 o2是CFace()的对象，也就是CFace()类型。

接口不可以实例化，但是可以实例他的实现类。

class Base
{
void test() {
System.out.println("Base.test()");
}
}
public class Child extends Base {
void test() {
System.out.println("Child.test()");
}
static public void main(String[] a) {
Child anObj = new Child();
Base baseObj = (Base)anObj; //子类对象赋给父类 真实对象是子类
baseObj.test();
}
}

输出： Child.test()

16.

A．abstract不能与final并列修饰同一个类

B．abstract类中可以有private的成员 接口不可以有private的成员

C．abstract方法必须在abstract类中

D．static方法中不能处理非static的属性

静态的属性和方法在内存中的存放地址与非静态的是不同的

constructor在一个对象被new时执行

int 属性初始值 0

1. 以下选项可替换题目中//add code here而不产生编译错误的是（ AD ）。（选择二项）

public abstract class MyClass{

public int constInt=5;

//add code here

public void method( ){

}

}

A. public abstract void method(int a); B. constInt =constInt+5; 逻辑代码 只能写在方法内部 C. public int method( ); D. public abstract void anotherMethod( );

抽象类有构造方法，接口没有

子类的访问修饰符不能比父类高

Abstract method cannot be static. True

抽象方法不能定义为静态方法

因为静态方法是属于类的，所以静态方法必须满足给类调用

static方法就必须有方法体，即已经实现了，也就不是抽象方法了。

接口中只有常量，没有变量

 

接口可以实现多继承制extends(父类接口)，接口中的属性只能是常量并且默认public static final修饰，接口中的方法默认是public abstract修饰的

final修饰的方法不能被重写，但可以被重载

---

class Parent{
          int x=10;
         public Parent(){
              add(2);
         }
         void add(int y){
              x+=y;
         }
    }
    class Child extends Parent{
         int x=9;
         void add(int y){
              x+=y;
         }
         public static void main(String[] args){
              Parent p=new Child();//用父类的引用指向子类的对象
              System.out.println(p.x);//p.x值是父类的10  结果：10
              System.out..println(((Child)p).x); //首先将p转换成Child类型 结果：9
         } 
    }
//子类Child的实例方法add(int y)覆盖了父类Parent的实例方法add(int y)，而子类的实例变量x则是隐藏了父类的实例变量x

子类重写父类方法时访问权限只能增大不能减小。

原因：编译器分析的时候语义问题

将子类中的fun方法改写为private，就会出现子类对象无法调用fun方法的现象，这就违背了继承和多态基本原则。

例如动物可以呼吸，那么任何属于动物的具体物种例如人都可以调用呼吸方法。如果将人类的呼吸方法改为private，那么人虽然身为动物却无法呼吸，这就违背了继承原则