#面向对象程序设计-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 += 20;
}
}
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 += 20; //从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));
}
}