OOP-Java基础知识总结

面向对象程序设计-Java基础知识总结

复习-T11

基本数据类型, 字符串, 基本计算和输入输出.

public class T11 {
    public static void main(String[] args) {//总是从main函数开始执行，main函数中的语句依次执行。
        int n = 10/4;       //int之间运算（这里是除法）的结果还是int类型的。
        double d = 123.456; //浮点型之间运算的结果还是浮点型类型的。 int和浮点型之间运算时，int型的数据转换成浮点型后再运算。
        boolean isTrue = true;  // true变成字符串后是"true"，false变成字符串后是"false"
        char type = 'A';    //就是一个字符A，''是用于表示这是一个字符，而不是一个变量A。
        String name = "Hello,OOP!".substring(6, 9); //得到的字符串是第[6,9)共3个字符"OOP"，H所在的位置为0
        System.out.println(n);
        System.out.println(d);
        System.out.println(isTrue);  // 任何数据用类似print()的函数输出时，实际上都转化成字符串才输出的
        System.out.println(type);
        System.out.println(name);
    }
}

复习-T12

数组和循环, 条件语句

public class T12 {
    public static void main(String[] args) {
        int[] ns = new int[4]; // ns是数组的名字， int是数组中元素的数据类型，new 是在内存中分配一个空间，int[4]是这个空间的大小可以放4个int类型的数。
        System.out.println(ns.length); //ns.length是数组ns中元素的个数
        for (int i = 0; i < ns.length; i++) { // 重复执行for后面的语句4次，i在每次循环中依次为0,1,2,3. 循环语句for用于控制程序的执行流程, 重复多次执行for后面的代码.
            if (i % 2 == 0) { //if语句会控制程序的执行流程.如果i除以2的余数等于0,那么执行后面的语句 
                ns[i] = i;
            } else {  // else和if语句配合,控制程序的执行流程.也就是如果i除以2的余数不等于0
                ns[i] = i * 2 + 10;
            }
        }
        for (int i = 0; i < ns.length; i++) {
            System.out.println(ns[i]);
        }
    }
}

复习-T21

类和对象, 类的静态成员, 对象的构造函数

class Bond {
    static int x = 0; //静态(static)变量在main函数执行前创建，并且静态变量在程序结束前不会消失。静态变量的初始化赋值，在main函数执行之前进行。以后不再执行。
    // 静态变量在每个当前类型的对象中都可以访问。
    int value;  //不是静态(static)的变量，每个创建(new)出来的对象都有一个相互独立的空间,在这个空间中保存这些成员变量(属性)。
    Bond(int n) { // 用new调用构造函数,创建一个新的对象.
        value = n;
    }
    int ask() {
        return 2 + value;
    }
    static int bye() {
        x++;    //静态(static)的函数中只能使用类中静态的数据
        return x;
    }
}
public class T21 {
    public static void main(String[] args) { 
        System.out.println(Bond.bye()); //输出一行，Bond这个类的bye()函数执行的结果
        Bond bond = new Bond(6); //对象类型的变量是对象的名字(地址),只有给对象类型变量赋值后, 对象类型的变量才代表一个实际存在的对象.
        System.out.println(bond.ask());
        System.out.println(Bond.bye());
        bond = new Bond(9); // 所有的=都是让左面变量代表右面的变量的值/对象/函数的返回值
        System.out.println(bond.ask());
        System.out.println(Bond.bye());
    }
}

复习-T22

对象之间的组成关系

class Value {
    int x;
    Value() {
        x = 2;
        System.out.println("x="+x);
    }
    Value(int x) {
        this.x = x;
        System.out.println("x="+x);
    }
    void inc(int x) {
        this.x += x;
    }
    void dec(int x) {
        this.x -= x;
    }
    int check() {
        System.out.println("check()");
        return x;
    }
    int get() {
        return x;
    }
}
class CGMJ {
    Value value; // 对象的属性(数据成员)可以是另外一个对象. 对象类型的变量是对象的名字(地址),只有给对象类型变量赋值后, 对象类型的变量才代表一个实际存在的对象.
    CGMJ() {
        value = new Value(4); //对象类型的变量是对象的名字(地址),只有给对象类型变量赋值后, 对象类型的变量才代表一个实际存在的对象.
    }
    void change(int x) {
        value = new Value(x); 
    }
}
public class T22 {
    public static void main(String[] args) {
        CGMJ cgmj = new CGMJ();
        cgmj.value.dec(6);
        System.out.println(cgmj.value.get());
        cgmj.change(7);
        cgmj.value.inc(8);
        System.out.println(cgmj.value.check());
    }
}

复习-T31

继承

class Bond {
    int value;
    public Bond() { //根据new后面的构造函数的参数,或者其它构造函数中this()函数的参数, 或者子类的super()函数的参数,决定实际调用哪个构造函数
        value = 2;
    }
    public Bond(int n) {//根据new后面的构造函数的参数,或者其它构造函数中this()函数的参数, 或者子类的super()函数的参数,决定实际调用哪个构造函数
        value = n;
    }
    void check() {
        System.out.println(value);
    }
}
class Bond1 extends Bond { //Bond1类在Bond类的基础上增加一个up()函数.Bond1类继承了Bond类的所有数据和函数.
    void up() {
        value += 4; //使用从Bond中继承来的value变量。
    }
    // 在Bond1没有写构造函数.Java会自动给Bond1生成一个不带参数的构造函数,并且其内部除了自动调用父类构造函数super()外,没有其它代码.
}
public class T31 {
    public static void main(String[] args) {
        Bond bond = new Bond(); 
        bond.check();
        bond = new Bond(6);
        bond.check();
        bond = new Bond1();//使用自动生成的Bond1()。Bond1()中自动调用super()，也就是Bond();
        bond.check();  //能调用哪些名称的函数，由变量的类型决定；实际调用哪个函数，由变量代表的实际对象决定。
        Bond1 bond1 = new Bond1();
        bond1.check();
        bond1.up();
        bond1.check();
    }
}

复习-T32

函数重载(overload)

class Bond2 {
    int value;
    Bond2() {
        value = 6;
    }
    void up() { //在Java看来up()和up(int n)是两个函数,相互之间没有关系.
        value++;
    }
    void up(int n) {//在Java看来up()和up(int n)是两个函数,相互之间没有关系.
        value += n;
    }
    void check() {
        System.out.println(value);
    }
}
class Bond3 extends Bond2 {
    void up() { //在Bond3类型的对象中，替换了Bond2中的重名函数up(),和up(int n)没有关系.
        value += 2;
    }
}
public class T32 {
    public static void main(String[] args) {
        Bond2 bond2 = new Bond2();
        bond2.up();
        bond2.check();
        bond2 = new Bond3(); //能调用哪些名称的函数，由变量的类型决定；实际调用哪个函数，由变量代表的实际对象决定。
        bond2.up();
        bond2.check();
        bond2.up(10);
        bond2.check();
        Bond3 bond3 = new Bond3();
        bond3.up();
        bond3.check();
        bond3.up(2);
        bond3.check();
    }
}

复习-T33

多态性, 函数覆盖(override)

class Bond4 {
    int value; //不是静态(static)的变量，每个创建(new)出来的对象都有一个相互独立的空间。
    Bond4() {
        value = 6; //不是静态(static)的变量，每个创建(new)出来的对象都有一个相互独立的空间。
    }
    void up() {
        value++; //不是静态(static)的变量，每个创建(new)出来的对象都有一个相互独立的空间。
    }
    void check() {
        up();  // 可能调用Bond4类中的up()， 也可能调用Bond5类中的up()。 如果当前对象(this)是Bond5类型的，那么调用Bond5类中的up()；如果当前对象(this)是Bond4类型的，不是Bond5类型的，那么调用Bond4类中的up()
        System.out.println(value);
    }
}
class Bond5 extends Bond4 {
    void up() { //在Bond5类型的对象中，替换了Bond4中的重名函数
        value += 2; //从Bond4中继承来的value变量
    }
}
public class T33 {
    public static void main(String[] args) {
        Bond4 bond4 = new Bond4();
        bond4.check();
        bond4.check();
        bond4 = new Bond5();
        bond4.check();
        Bond5 bond5 = new Bond5();
        bond5.check();
        bond5.check();
    }
}

复习-T41

异常和异常处理

class ExceptionA extends Exception { //从Exception扩充出来的子类, 除了可以用于throw外,和普通的类的使用方式是同样的.
    String message;
    public ExceptionA(String message) {
        this.message = message;
    }
    @Override
    public String getMessage() {
        return message;
    }
}
class Bond {
    int value;
    Bond() {
        value = 10;
    }
    int change(int n) throws ExceptionA {
        if (value > n) {
            value -= n;
            System.out.println("A03");
        } else {
            System.out.println("A00");
            throw new ExceptionA("A01"); //转到代码调用层次结构中第一个和ExceptionA匹配的catch部分执行.
        }
        System.out.println("A02");
        return value;
    }
    void clear() {
        value = 15;
        System.out.println(value);
    }
}
public class T41 {
    public static void main(String[] args) {
        Bond a = new Bond();
        try {
            a.change(6);
            a.change(6);
        } catch (ExceptionA e) {
            System.out.println(e.getMessage());
        } finally { //无论是否发生异常都执行的代码写在finally段中.
            a.clear();
        }
    }
}

复习-T51

封装, 继承, 多态性, 静态成员的综合练习

class Bond {
    static int counter = 0; //静态(static)变量在main函数执行前创建，并且静态变量在程序结束前不会消失。静态变量的初始化赋值，在main函数执行之前进行。以后不再执行。
    // 静态变量在每个当前类型的对象中都可以访问。
    int value; //不是静态(static)的变量，每个创建(new)出来的对象都有一个相互独立的空间。
    public Bond(int value) {  // Bond(int value)的参数使用变量value，和上一行的value重名。
        this.value = value;   // =右面的value是Bond(int value)的参数value，=左面的this.value是当前对象的一个属性（数据成员）。
        if(counter<2){ // 静态变量在每个当前类型的对象中都可以访问，并且保持最新的值。
            System.out.println("Bond(int)");
        }
        counter++;  // 静态变量在每个当前类型的对象中都可以访问，并且保持最新的值。
    }
    public Bond() {
        value = 2; //不是静态(static)的变量，每个创建(new)出来的对象都有一个相互独立的空间。
        if(counter<2){ // 静态变量在每个当前类型的对象中都可以访问，并且保持最新的值。
            System.out.println("Bond()");
        }
        counter++;  // 静态变量在每个当前类型的对象中都可以访问，并且保持最新的值。
    }
    void up() {
        value++; //不是静态(static)的变量，每个创建(new)出来的对象都有一个相互独立的空间。
    }
    void up(int n) {
        value += n; //不是静态(static)的变量，每个创建(new)出来的对象都有一个相互独立的空间。
    }
    int change() {
        return value; //不是静态(static)的变量，每个创建(new)出来的对象都有一个相互独立的空间。
    }    
    int buyBoth(Bond bond) {
        up(); // 可能调用Bond类中的up()， 也可能调用Bond1类中的up()。 如果当前对象(this)是Bond1类型的，那么调用Bond1类中的up()；如果当前对象(this)是Bond类型的，不是Bond1类型的，那么调用Bond类中的up()
        bond.up(); //如果bond对象实际上是Bond1类型的，那么调用Bond1类中的up()；如果bond对象实际是Bond类型的，不是Bond1类型的，那么调用Bond类中的up()
        return value + bond.value; //不是静态(static)的变量，每个创建(new)出来的对象都有一个相互独立的空间。
    }
}
class Bond1 extends Bond {
    public Bond1() {  //自动调用Bond的构造函数super()
        System.out.println(value);
    }
    public Bond1(int num) {
        super(num); //明确指定调用Bond的构造函数super(num)
        System.out.println(num);
    }
    void up() {  //在Bond1类型的对象中，替换了Bond中的重名函数
        value += 10;
    }
}
public class T51 {
    public static void main(String[] args) {
        Bond bond = new Bond1(); //能调用哪些名称的函数，由变量的类型决定；实际调用哪个函数，由变量代表的实际对象决定。
        bond.up();
        System.out.println(bond.change());
        Bond bond1 = new Bond(6);
        bond1.up();
        System.out.println(bond1.buyBoth(bond));
        Bond1 bond2 = new Bond1();
        bond2.up();
        System.out.println(bond2.change());
        System.out.println("counter="+Bond.counter);
        bond2 = new Bond1();
        bond2.up(10);
        System.out.println(bond2.buyBoth(bond1));
    }
}