面向对象程序设计期末复习

基础语法

Java程序语句执行的顺序

Java包括4种基本控制结构：顺序结构、选择结构、循环结构、异常处理逻辑结构

（如果是三个空就是：顺序、选择、循环）

权限修饰符

public：类内部、本包、子类、外部包

protected：类内部、本包、子类、外部包

default：类内部、本包

private：类内部

不写修饰符默认是default

注释

// 单行注释

/*
	多行
	注释
*/

/**
 * 文档
 * 注释
**/

定义标识符

只能由数字、字母、下划线、\(\$\)组成

不能以数字开头

变量与产量

Java是强类型语言，即每个变量都有类型。

整形

类型	存储需求	取值范围
int	4B	[-2147483648,-2147483648]（刚刚20亿）
short	2B	[-32768,32767]
long	8B	[-9223372036854775808,9223372036854775807]
byte	1B	[-128,127]

因为Java是在Java虚拟机上运行，所以取值范围与平台无关

注意Java没有任何无符号整型

普通的数字就是int，long有一个后缀l或L（如4000000000L)

十六进制有前缀0x或0X，八进制有前缀0

Java7之后就有了，二进制前缀0b或0B，同时也可以在数字中插入下划线1_000_000_000，编译时编译器会自动去掉

浮点型

类型	存储需求	取值范围
float	4B	大约6到7位
double	8B	大约15位

同时有三个常数表示溢出或出错

• 正无穷大Double.POSITIVE_INFINITY
• 负无穷大Double.NEGATIVE_INFINITY
• 不是一个数Double.NaN

char型

char型用于表示单个字符，通常是占16位，当有些字符需要消耗两个char

char采用的是Unicode编码，Unicode前128位于ASCll相同

boolean型

boolean布尔型只有两个值false和true，并且布尔型不能像c++中那样用0/1表示，也不能于整型转换

Java引用数据类型

String、数组、类Class、接口interface

变量的作用域

1. 成员变量，在类体里定义的变量叫成员变量，他的作用域是整个类
2. 局部变量，在一个方法或方法类代码块定义的变量成为局部变量

常量

在变量前加一个final即可。

注意变量赋值时float a = 133.3f要带上f,long a = 13456l要带上l

运算符

算数运算符

Java中的算数运算符有+,-,*,/,%，整体和c++类似，特别的对于/两个数都是整型则为整型除法，否则均为浮点数除法## 组合赋值和运算符

组合赋值运算符

x+=4等价于x = x + 4，如果左右的数据类型不同就会发生强制类型转换，如果x是int类型x += 3等价于x = (int) (x + 3.5)

自增自减运算符

和C的运算符基本相同有++,--两种，既有前缀也有后缀两种

位运算符

在Java中有四种位运算符

$（and）|（or）^（xor）~（not）

同时还有<<左移、>>右移，还有一种特殊的运算符是>>>也是左移，与>>不同的是他是用0来填充高位，而>>是用符号位来填充

逻辑运算符

&&与、||或、!非

三目运算符

x?a:b,x为真返回a，否则返回b

for each 循环

public class Main {
    public static void main(String[] args) {
        int [] a = new int[]{1,9,2,6,0,8,1,7};
        for (int val : a) {
            System.out.println(val);
        }
    }
}

数组

数组是不能再前面的中括号写元素个数的

数组声明

int a[] = new int[];
int [] a = new int[];

数组的大小a.length

数组的拷贝

int b[] = a; // 这里a b的引用是一样的
int b[] = a.clone(); // 这里的引用是不一样的
// 复制前几个 
int b[] = Arrays.copyOf( a , 3 );
// 复制任意连续几个
int b[] = Arrays.copyOfRange( a , 2 , 5);

数组转化成字符串

Arrays.toString(a);

数组排序

Arrays.sort(a);

面向对象的特征

封装

通过 private、default、protected、public 关键字实现属性或方法的封装，仅对外提供公共的访问方式（get、set）

封装的好处：

1. 实现数据和方法的隐藏
2. 对外部类做有限的访问，开发者可以自由的改变类的内部实现
3. 提高了代码的重用性

多态

一个对象变量的可以指向多种实际类型对象的现象被称为“多态”

好处：提高了代码的维护性；提高了代码的扩展性

实现方法：借口实现、继承父类的方法进行重写、同一个类中的方法进行重载、父类引用子类指向的对象

继承

概念：可以使得子类具有父类的属性和方法，还可以在子类中重新定义，以及 追加属性和方法

实现：通过 extends

好处：继承可以让类与类之间产生关系，子父类关系，产生子父类后，子类则可以使用父类中非私有的成员

上转型

class Father {
    int get(){ return 1; }
    int get1(){ return 3; }
}

class Son extends Father{
    int get() { return 2; }
    int get2() { return 3; }
}

public class Main {
    public static void main(String[] args) {
        Father a = new Son();
        System.out.println(a.get());
        // 这里的输出结果是 2;
    }
}

继承性

所有类都是Object类的子类

继承的关键字是extends，继承后子类有父类的非私有属性或方法

子类可以重写父类的方法

封装性

将类的某些信息隐藏在类的内部，不允许外部程序直接进行访问，而是通过 getter、setter 的方法来对隐藏的信息进行访问和操作

封装要把对应的属性设置为private

构造方法

主要用来在创建对象时初始化对象，即为对象成员变量赋初始值，总与 new 运算符一起使用在创建对象的语句中。

一个类中可以有多个构造方法，可根据其参数个数的不同或类型的不同来区分他们，即构造函数的重载。

重写重载

重载

概念

1. 必须在同一个类中
2. 方法名相同
3. 参数的个数、顺序、类型不同
4. 与方法的修饰符和返回值无关

重写

当父类中的方法无法满足子类的需求时候，需要方法重写

1. 重写方法必须和父类的方法一样（包括返回值类型、方法名、参数列表）
2. 子类中重写的方法的访问权限不能低于父类中的访问权限

this super

Java 中为了解决变量命名的冲突和不确定性问题，引入了关键字 this 表示所在方法的当前引用

1. 构造函数中指该构造器创建的新对象

public class A {
    int a;
    A( int a ){
        this.a = a;
    }
}

2. 方法中调用该方法的对象

public class A {
    void a(){
        System.out.println("a");
    }
    void ab(){
        this.a();
        System.out.println("b");
    }
}

3. 在类本身的方法中应用累的全局变量和方法

void setName(String name ){
    this.name = name;
}

注意this只能在非静态方法中使用

super 关键字主要存在于之类的方法中，用于指向子类对象中的父类对象，可以访问父类的属性、函数以及构造函数

static final

static加了之后就变成静态变量、方法。静态的方法和变量可以直接通过类名调用，因为他在初始化前就被加载了

final 修饰的类不能被继承，修饰的方法不能被重写但子类可以调用父类的 final 修饰的方法，final 修饰的变量不能改变，final 修饰的引用类型变量，引用变量引用不可变但引用内容可以变

抽象类

用 abstract 修饰的类

里面可以有普通类型的变量，也可以有静态方法

里面可以有普通方法，也可以有抽象类型的方法，抽象方法不能有方法体{}

抽象类被非抽象子类继承，必须实现所有的抽象方法

接口

interface 是结构的关键字，接口实现implements

接口中所有的方法都是public abstract，所有变量都是public abstract final，可以省略

接口中方法都不能被实现，接口可以多实现

多态

条件

1. 继承
2. 重写
3. 父类引用指向子类对象