面向对象编程(含java练习题)

注:截图和题目均来自李刚老师的《疯狂Java讲义》

一类及其成员定义

　　1.定义类

[修饰符] class 类名
{
  零个到多个构造器定义...
  零个到多个成员变量...
  零个到多个方法            
}

　　修饰符可以是public、final、abstract，也可以省略。其中final和abstract只能出现一个。

　　2.定义成员变量

[修饰符] 类型 成员变量名 [=默认值];

　　修饰符可以省略，也可以是public、private、protected、static、final，其中public、private、protected三个最多只能出现一个，可以与static、final组合起来修饰成员变量

　　3.定义方法

[修饰符] 方法返回值类型 方法名(形参列表)
{
  //方法体      
}

　　修饰符可以省略，也可以是public、private、protected、static、final、abstract，其中public、private、protected三个最多只能出现一个；final、static和abstract最多只能出现一个。

　　4.构造器　

[修饰符] 构造器名(形参列表)
{
  //构造器执行体  
}

　　修饰符可以省略，也可以使public、private、protected其中之一。

　　5.初始化代码块

　　6.this的使用

　　this总是指向调用该方法的对象(实际中的类型对象)或正在初始化的对象。

　　出现位置:

　　　　a.构造器第一行（标识正在初始化的对象）

　　　　b.方法中

　　　　　　调用另一个方法(和没有this效果一样)

　　　　　　this.成员变量(防止被形参或者局部变量替换)

　　7.方法的参数传递机制是值传递

class DataWrap
{
    int a;
    int b;
}
public class ReferenceTransferTest
{
    public static void swap(DataWrap dw)
    {
        int tmp = dw.a;
        dw.a = dw.b;
        dw.b = tmp;
        System.out.println("swap方法里，a成员变量的值是"
            + dw.a + "；b成员变量的值是" + dw.b);
        dw = null;
    }
    public static void main(String[] args)
    {
        DataWrap dw = new DataWrap();
        dw.a = 6;
        dw.b = 9;
        swap(dw);
        System.out.println("交换结束后，a成员变量的值是"
            + dw.a + "；b成员变量的值是" + dw.b);
    }
}

　　8.形参个数可变的方法

　　　　方法中最多只能有一个个数可变的形参，且位置只能出现在形参列表最后。

　　9.形参个数可变的方法的重载

public class OverloadVarargs
{
    public void test(String msg)
    {
        System.out.println("只有一个字符串参数的test方法 ");
    }
    // 因为前面已经有了一个test()方法，test()方法里有一个字符串参数。
    // 此处的个数可变形参里不包含一个字符串参数的形式
    public void test(String... books)
    {
        System.out.println("****形参个数可变的test方法****");
    }
    public static void main(String[] args)
    {
        OverloadVarargs olv = new OverloadVarargs();
        // 下面两次调用将执行第二个test()方法
        olv.test();
        olv.test("aa" , "bb");
        // 下面将执行第一个test()方法
        olv.test("aa");
        // 下面调用将执行第二个test()方法
        olv.test(new String[]{"aa"});
    }
}

　　10.用递归写出文件遍历

　　11.方法重载

　　注意两同一不同(同一个类中方法名相同，参数列表不同)

　　12 注意，实例可以访问类，但是类不能访问实例

　　13.所有变量及初始化

　　实体变量和类变量都会自动初始值，但方法局部变量和代码块局部变量不会自动初始化，未初始化使用报错。

public class BlockTest
{
    public static void main(String[] args)
    {
        {
            // 定义一个代码块局部变量a
            int a;
            // 下面代码将出现错误，因为a变量还未初始化
             System.out.println("代码块局部变量a的值：" + a);
        }
    }
}

　　14 数据在内存中的存储

　　15 访问控制符

　　16 是不是调用构造器就会创建一个对象

　　17 java子类不能获得父类的构造器

　　18 方法重写(两同两小一大)

　　19 父子类可以有方法的重载

　　20 static方法中不会有this和supper

　　21 若父类和子类中有相同的成员变量，内存图示

　　　22 多态

class BaseClass
{
    public int book = 6;
    public void base()
    {
        System.out.println("父类的普通方法");
    }
    public void test()
    {
        System.out.println("父类的被覆盖的方法");
    }
}
public class SubClass extends BaseClass
{
    //重新定义一个book实例变量隐藏父类的book实例变量
    public String book = "轻量级Java EE企业应用实战";
    public void test()
    {
        System.out.println("子类的覆盖父类的方法");
    }
    public void sub()
    {
        System.out.println("子类的普通方法");
    }
    public static void main(String[] args)
    {
        // 下面编译时类型和运行时类型完全一样，因此不存在多态
        BaseClass bc = new BaseClass();
        // 输出 6
        System.out.println(bc.book);
        // 下面两次调用将执行BaseClass的方法
        bc.base();
        bc.test();
        // 下面编译时类型和运行时类型完全一样，因此不存在多态
        SubClass sc = new SubClass();
        // 输出"轻量级Java EE企业应用实战"
        System.out.println(sc.book);
        // 下面调用将执行从父类继承到的base()方法
        sc.base();
        // 下面调用将执行从当前类的test()方法
        sc.test();
        // 下面编译时类型和运行时类型不一样，多态发生
        BaseClass ploymophicBc = new SubClass();
        // 输出6 —— 表明访问的是父类对象的实例变量
        System.out.println(ploymophicBc.book);
        // 下面调用将执行从父类继承到的base()方法
        ploymophicBc.base();
        // 下面调用将执行从当前类的test()方法
        ploymophicBc.test();
        // 因为ploymophicBc的编译类型是BaseClass，
        // BaseClass类没有提供sub方法,所以下面代码编译时会出现错误。
        // ploymophicBc.sub();
    }
}

　　23 instanceof

public class InstanceofTest
{
    public static void main(String[] args)
    {
        // 声明hello时使用Object类，则hello的编译类型是Object，
        // Object是所有类的父类, 但hello变量的实际类型是String
        Object hello = "Hello";
        // String与Object类存在继承关系，可以进行instanceof运算。返回true。
        System.out.println("字符串是否是Object类的实例："
            + (hello instanceof Object));
        System.out.println("字符串是否是String类的实例："
            + (hello instanceof String)); // 返回true。
        // Math与Object类存在继承关系，可以进行instanceof运算。返回false。
        System.out.println("字符串是否是Math类的实例："
            + (hello instanceof Math));
        // String实现了Comparable接口，所以返回true。
        System.out.println("字符串是否是Comparable接口的实例："
            + (hello instanceof Comparable));
        String a = "Hello";
//        // String类与Math类没有继承关系，所以下面代码编译无法通过
//        System.out.println("字符串是否是Math类的实例："
//            + (a instanceof Math));
    }
}

　　24 将类设置成最终类的方法

　　　　a.final

　　　　b.所有方法都改成private

题目

1.写出下面执行结果的输出

class Creature
{
    public Creature()
    {
        System.out.println("Creature无参数的构造器");
    }
}
class Animal extends Creature
{
    public Animal(String name)
    {
        System.out.println("Animal带一个参数的构造器，"
            + "该动物的name为" + name);
    }
    public Animal(String name , int age)
    {
        // 使用this调用同一个重载的构造器
        this(name);
        System.out.println("Animal带两个参数的构造器，"
            + "其age为" + age);
    }
}
public class Wolf extends Animal
{
    public Wolf()
    {
        // 显式调用父类有两个参数的构造器
        super("灰太狼", 3);
        System.out.println("Wolf无参数的构造器");
    }
    public static void main(String[] args)
    {
        new Wolf();
    }
}

2.解释下面程序为什么会报错

class Base
{
    public Base()
    {
        test();
    }
    public void test()           // ①号test()方法
    {
        System.out.println("将被子类重写的方法");
    }
}
public class Sub extends Base
{
    private String name;
    public void test()         // ②号test()方法
    {
        System.out.println("子类重写父类的方法，"
            + "其name字符串长度" + name.length());
    }
    public static void main(String[] args)
    {
        // 下面代码会引发空指针异常
        Sub s = new Sub();
    }
}

答案

面向对象编程(含java练习题)

猜你喜欢