java中北大学ppt总结+课后习题第三章（小宇特详解）
抽象
对一组具有相同属性和相同行为的对象进行抽象得到类。包括两方面的抽象：
数据抽象：描述某类对象的共同属性。
代码或过程抽象：描述了某类对象具有的共同行为。
以学籍管理程序为例,通过对学生进行归纳、分析,抽取出其中的共性,可以得到如下的抽象描述:
共同的属性(数据抽象部分):姓名、学号、成绩等。
共同的操作(代码抽象部分):数据录入、数据修改和数据输出等。
共同的属性(数据抽象部分):姓名、学号、成绩等。
String name; //姓名
int number; //学号
float score; //成绩
共同的操作(代码抽象部分):数据录入、数据修改和数据输出等。（使用自定义方法来执行）
setInfo(){….}; //数据录入函数
modifyInfo(){….}; //数据修改函数
printInfo(){….}; //数据输出函数
在程序设计方法中：
封装具有两方面的含义:
一是将有关的数据和操作代码封装在一个对象中,各个对象相对独立、互不干扰。
二是将对象中某些数据与操作代码对外隐蔽,即隐蔽其内部实现细节,只留下少量接口,以便与外界联系,接收外界的消息。这种对外界隐蔽的做法称为信息隐蔽。
封装可以将对象的使用者与设计者分开；
使用者不必知道对象行为实现的细节，只需要使用设计者提供的接口让对象去做。这样，大大降低了人们操作的复杂程度，还有利于数据安全。从而减轻了开发一个软件系统的难度。
父类与子类
面向对象软件技术的许多强有力的功能和突出的优点，都来源于把类组成一个层次结构的系统（类等级）：
一个类的上层可以有父类，下层可以有子类。
这种层次结构的一个重要性质是继承性，一个类直接继承了其父类的全部特性（数据和操作），同时又可以扩展或增加一些新的特性。
继承具有传递性。一个类实际上继承了它所在的类等级中在它上层的全部父类、祖先类的所有特性。
单继承与多重继承：
单继承：一个类只允许有一个父类，例如在Java中。
多重继承：一个类允许有多个父类，例如在C++中。
继承性使得相似的对象可以共享程序代码和数据结构，从而大大减少了程序中的冗余信息。
多态
多态（polymorphism）有两种意义：
一种是操作名称的多态，即多个操作具有相同的名字，可以向对象传递不同的消息（方法名相同，参数不同），让对象根据消息来产生不同的行为 。例如：计算圆的面积，参数只有一个，计算长方形的面积，参数需要两个。——方法重载
另一种是和继承有关的多态，向对象发送相同的消息,可以根据对象的实际类型产生不同的行为 。例如父类是动物类，有发声的方法，子类继承父类并重写该方法，如果动物的实例是狗，则“汪汪…”，如果是猫，则“喵喵…”
实现类
类是用来创建对象的模板，类的实现包括两部分，即类的声明和类体。
class 类名{
//成员变量
//成员方法
}
其中class 类名是类的声明部分，两个大括号以及之间的内容是类体。类体的内容由两部分构成：
成员变量：进行变量的声明，用来刻画属性；
成员方法：进行方法的定义，用来刻画功能；
类的成员变量
成员变量的类型可以是Java中的任意一种数据类型，包括基本类型和用户自定义类型。
成员变量如果没有初始化，编译器会自动初始化成缺省值。
boolean缺省值false。
byte short int long缺省值0。
char 缺省值’\0’或者0。
float double 缺省值0.0。
字符串、数组、对象缺省值null。
成员变量可以放在类块的任意位置，不能放在函数之中。
class ClsA{
int m_a; //定义一个成员变量
int m_b,m_c; //定义多个成员变量
int m_d=10; //定义成员变量的时候初始化。
int m_e=20,m_f,m_g=30;
//定义多个成员变量，根据需要初始化
}
成员变量的使用：
在类内部，直接使用。
作用域在类块范围内。
class ClsA{
int m_a = 20;
void show(){
System.out.println(m_a); //直接使用
}
}
生成对象后，通过对象使用（修饰符号来决定访问范围）
ClsA obja = new ClsA();
obja.m_a = 50; //通过对象使用
类的成员方法
最基本的方法声明包括方法名和方法的返回类型，当一个方法不需要返回数据时，返回类型必须是void，如果方法需要带参数，参数是用逗号隔开的一些变量声明。
修饰符号 返回类型 方法名（参数类型 参数,……）
{
语句组；
}
例一
public static void main（String[] args）
{
System.out.println(“Hello World!”);
}
类的成员方法放置在类块之中，而且可以放置在任意位置。
class ClsA{
void show(){
}
}
类成员方法的调用
在类内部直接调用
通过对象调用（修饰符号来决定访问范围）
class ClsA{
void show(){
}
void showTwo(){
show(); //直接调用
}
}
ClsA obja=new ClsA();
obja.show();
//通过对象调用
类的成员修饰符
在类的内部，可以直接访问成员变量（或方法）。
class TestDemo {
int a = 5;
int b = a + aa() ;
int aa() { return a * a; }
void abb() { System.out.println(a + aa());
System.out.println(b);
}
public static void main(String[] args){
TestDemo td = new TestDemo();
td.abb();
}
}
class TestDemo {
public static void main(String[] args){
TestDemo td = new TestDemo();
td.abb();
}
}
在类的外部通过对象访问成员变量或者成员方法的时候情况却有所不同，Java语言通过修饰符语法限制对成员的访问。
类的成员提供4个访问限制修饰符：
private：限制在类块内部访问。
缺省 ：什么都不添加，限制在同一个包内访问。
protected：限制同一个包内或其他包中的子类中访问。
public：没有限制的访问，即任何位置都可以访问。
限制修饰符的使用规则：
建议成员变量使用private修饰，限制对成员变量的直接访问。
对private的成员变量的访问通过专门的方法。
对private成员变量访问的方法建议使用如下命名规则：
修改/设置成员变量xxxx的值建议命名为setXxxx，相应的成员变量称为可写属性。
获取成员变量的值建议命名为getXxxx，如果是boolean变量，也可以命名为isXxxx。相应的成员变量称为可读属性。
成员方法根据需要设置修饰符，一般建议为public。
修饰类成员的另外一个关键字：static
在Java语法中允许在成员前添加static，称为全局变量或者全局方法。
static修饰符可以与public，final等修饰符同时使用。与其他修饰符无先后关系。
临时变量（局部变量）是不能使用static修饰的。
被static修饰的变量或方法建议不要通过对象访问，因为不属于对象，而是通过类名访问；
没有使用static修饰的成员变量（或方法），通常称为实例变量（或方法）。实例变量（或方法）必须通过对象访问，而不能通过类名访问。
实例方法可以访问实例变量（或另一个实例方法），也可以访问]全局变量（或方法）；全局方法可以访问全局变量（或另一个全局方法），但不能访问实例变量（或方法）。
定义并使用全局变量和方法的语法。
public class ClsA{
static public int a=30;
private int m_b=40;
public static void show(){
a=50;
m_b=60;//static方法不能访问成员变量。
}
}
// 全局变量或方法在类外均通过类名访问
ClsA.a=9999;
ClsA.show();
方法重载
方法重载是多态性的一种。
对象的功能通过类中的方法来体现，功能的多态性就是通过方法重载来体现。
方法重载的意思是：一个类中可以有多个方法具有相同的名字，但这些方法的参数必须不同，即或者是参数的个数不同，或者是参数的类型不同。
当调用一个重载的方法时，Java编译器就是先根据方法名，再根据方法的参数类型、参数顺序、参数个数匹配结果来确定匹配哪个方法。（与返回类型无关！）
例一
public class TestOverload {
public static void main(String[] args) {
float circleArea = getArea(2.0f);
double rectangleArea1 = getArea(1.0f, 2);
float rectangleArea2 = getArea(2, 1.0f);
float cuboidArea = getArea(3, 4, 5);
}
public static float getArea(float r) {
return 3.14f * r * r;
}
public static double getArea( float x, int y) {
return x * y;
}
public static float getArea(int x, float y) {
return x * y;
}
public static float getArea(float x, float y, float z) {
return (x * y + y * z + z * x) * 2;
}
}
this关键字
在Java的类中引入了this关键字，this的功能有两个：
用来调用类中的其他构造方法。
用来表示类产生的对象本身。当用类产生的对象是obja时，this就是obja，如果对象是objb，this就是objb。
解决成员命名冲突的问题。当成员变量名与局部变量名冲突时，this等同于作用域。
class Student{
private String name;
public void setName(String name) {
this.name=name;
构造方法
Java类创建对象的时候需要分配空间，并提供对成员变量的初始化，这些工作都是由一个特殊的方法完成：构造方法。
构造方法的特殊之处在于：
构造方法名与类名必须一致，构造方法没有返回值，也不能使用void修饰。
不能像一般方法那样调用，有自己独特的调用语法。
如果用户没有定义构造方法，编译器会自动创建一个缺省构造方法(没有参数的构造方法）。
如果用户定义了构造方法，则编译器不会自动创建缺省构造方法。
缺省构造方法的语法
class Student{
private String name;
private int age;
//缺省构造方法：没有返回值类型，没有参数
Student(){…
}
}
Student s=new Student(); //构造方法使用new调用。
带参构造方法与构造方法重载
class Student{
private String name;
private int age;
public Student(String name) {
this.name=name;
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
}
Student s2 = new Student(“李四”,18);
Student s1 = new Student(“张三”);
使用this调用构造方法
class Student{
private String name;
private int age;
public Student(String name){
this.name = name;
}
public Student(String name, int age){
this(name);
thia.age = age;
}
}
Student s1 = new Student(“张三” , 18);
例二
想计算某个盒子（正方体或长方体）的体积，如何来描述这个盒子类？
public class Box {
private float length;
private float width;
private float height;
//构造正方体的盒子
public Box(float side){
length = side;
width = side;
height = side;
}
//构造长方体的盒子
public Box(float length, float width, float height) {
this.length = length;
this.width = width;
this.height = height;
}
public float getVolume() {
return length * width * height;
}
}
UML简介及UML类图
在UML类图中，使用一个长方形描述一个类的主要构成，将长方形垂直地分为三层。
第1层是名字层
如果类的名字是常规字形，表示该类是具体类；
如果类的名字是斜体字形，表示该类是抽象类；
第2层是变量层，也称属性层，列出类的成员变量及类型，格式是“变量名字：类型”。
可以根据设计的需要只列出最重要的成员变量的名字。
第3层是方法层，也称操作层，列出类的方法及返回类型，格式是“方法名字（参数列表）：类型”。
可以根据设计的需要只列出最重要的成员方法的名字。
注意：表示成员变量和成员方法时
如果访问权限是public,前面用+修饰。
如果访问权限是private,前面用-修饰。
如果访问权限是protected,前面用#修饰。
如果访问权限是缺省,前面不使用任何修饰。
这里做一下例二的UML图
用类图描述例3.2所描述的盒子类。
UML类图中的关联关系
UML类图中的关联关系
如果A类中成员变量是用B类来声明的变量，那么A和B的关系是关联关系，称A关联于B。
如果A关联于B，那么UML通过使用一个实线连A和B的UML图，实线的起始端是A的UML图，终点端是B的UML图，但终点端使用一个指向B的UML图的方向箭头表示实线的结束。
UML类图中的依赖关系
如果A类中某个方法的参数是用B类来声明的变量或某个方法返回的数据类型是B类型的，那么A和B的关系是依赖关系，称A依赖于B。
如果A依赖于B，那么UML通过使用一个虚线连A和B的UML图，虚线的起始端是A的UML图，终点端是B的UML图，但终点端使用一个指向B的UML图的方向箭头表示虚线的结束。
UML类图中的泛化关系
就是指类的继承关系。
如果一个类是另一个类的子类，那么UML通过使用一个实线连接两个类的UML图来表示二者之间的继承关系，实线的起始端是子类的UML图，终点端是父类的UML图，但终点端使用一个空心的三角形表示实线的结束。
UML类图中的实现关系
如果一个类实现了一个接口，那么类和接口的关系是实现关系，称类实现接口。
UML通过使用虚线连接类和它所实现的接口，虚线起始端是类，虚线的终点端是它实现的接口，但终点端使用一个空心的三角形表示虚线的结束。
对象
类和对象的关系
在分析阶段，类是对具有相同属性和共同行为的一组对象的抽象；
在设计阶段，类又是创建对象的模板，相应地，对象也称为类的实例。
声明对象
类是创建对象的模板，类可以看成是用户自定义的数据类型，用类声明的变量称为对象或实例。
声明对象的语法（与变量声明一样）
类名 对象名;
类名 对象名1，对象名2，……；
例如：
Student stu1;
这里，Student是一个类的名字，stu1是声明的对象的名字。
创建对象
使用new运算符和类的构造方法为声明的对象分配内存，即创建对象。
创建对象的语法：
类名 对象名;
对象名 = new 构造方法名(参数1，参数2，……);
类名 对象名 = new 构造方法名(参数1，参数2，……);
例如
Student stu1;
stu1 = new Student(“张三”, 19);
Student stu2 = new Student(“李四”, 20, true);
Box b1 = new Box(10);
Box b2 = new Box(10,20,30);
对象的内存模型
Java把内存划分为两种：一种是栈内存，另一种是堆内存。
在函数中定义的一些基本类型的变量和数组、对象的引用变量都是在函数的栈内存中分配；
堆内存用来存放由new创建的对象和数组；
声明对象时，仅是在栈内存定义了一个特殊类型的变量，这个变量用来存放堆内存中为对象分配的内存空间的首地址，这样，栈中的这个变量就成了对象的引用变量，以后就可以在程序中使用栈中的引用变量来访问堆中的对象了。
这里和第一章的一样
创建对象本质上要做两件事；
栈内存（存放引用变量）和堆内存（存放对象本身）。
例三
画出下面两行代码执行完后内存的状态。
Student stu1;
stu1 = new Student("张三", 19);
Student stu2 = new Student("李四", 20, true);
成员变量初始化
成员变量初始化有三种方式：
方式1：构造器初始化
方式2：成员方法初始化
方式3：直接提供缺省值初始化
class Student{
private String name;
private int age = 18; //方式3：缺省值初始化
public Student(String name){
this.name = name;
} //方式1：使用构造器初始化。
public void setAge(int age){
this.age = age;
} //方式2：使用方法初始化。
}
Student s1 = new Student(“张三”); //方式1：使用构造器初始化。
s1.setAge(23); //方式2：使用方法初始化。
初始化块
在Java语言中还有比构造方法还先调用的语法机制（最先执行代码的语法机制）：
初始化块，也称静态匿名块。
初始化块是用来初始化全局变量与全局方法的（使用static修饰）。
语法：
class Student{
static{
System.out.println(“静态匿名块”);
}
…
}
使用对象
对象不仅可以操作自己的变量改变状态，而且能调用类中的方法产生一定的行为。
对象操作自己的变量（对象的属性）
对象在创建之后，可以使用运算符“.” 实现对自己的非private的变量的访问，访问格式如下：
对象.变量；
对象调用类中的方法（对象的功能）
对象在创建之后，可以使用运算符“.”调用创建它的类中的非private的方法，访问格式如下：
对象.方法
例如float volume = b1.getVolume();
析构器与对象释放
JVM与内存释放
由于Java使用JVM，所以Java的内存（对象）释放采用自动回收机制。
垃圾回收机在释放对象前会调用一个特殊的方法：
protected void finalize()；//析构方法或析构器
内存释放：
JVM的垃圾回收器一般在内存吃紧的时候提高内存清理的频率。
只有那些没有对象引用的内存会被释放。
把对象赋值为null，则对象与空间的引用关系就割断。
例四
使用例3.2中的盒子类构造一个正方体的盒子和一个长方体的盒子，分别计算输出体积。
public class TestBox {
public static void main(String[] args) {
Box b1 = new Box(10);
Box b2 = new Box(10,20,30);
System.out.println("正方体体积："+b1.getVolume());
System.out.println("长方体体积："+b2.getVolume());
}
}
对象的组合
一个类的成员变量可以是 Java的任何数据类型；
一个类的成员变量可以是另一个类的对象，换言之，一个类可以把另一个类的对象作为自己的成员变量；
如果用这样的类创建对象，那么该对象中就会有其他对象。也就是说，该对象将其他对象作为自己的组成部分。这就是对象的组合。
如：圆柱都有一个圆底，圆柱将圆对象作为自己的成员。
例五
计算一个圆柱的体积。
解答：
（1)声明一个圆类，能计算圆的面积；
（2)声明一个柱体类，底面是圆，能计算柱体的体积;
（3)写一个测试类，计算柱体的体积。
声明一个圆类，能计算圆的面积；
class Circle {
private float r;
public Circle(float r) {
this.r = r;
}
public float getArea() {
return 3.14f * r * r;
}
}
声明一个柱体类，底面是圆，能计算柱体的体
class Pillar{
Circle bottom;
float height;
public Pillar(Circle bottom,float height) {
this.bottom = bottom;
this.height = height;
}
public float getVolume() {
return bottom.getArea() * height;
}
}
写一个测试类，计算柱体的体积。
public class TestPillarVolume{
public static void main(String[] args) {
Circle c = new Circle(2);
Pillar pillar = new Pillar(c,10);
/* 上面两句等价于这一句
Pillar pillar = new Pillar(new Cirle(2),10); */
System.out.print("该圆柱的体积为:");
System.out.println(pillar.getVolume());
}
}
包
定义包
包是Java语言中有效地管理类的一个机制，使用包的目的是有效地区分名字相同的类。
假如两个开发人员在同一个软件项目中创建了两个名字相同的类，这时可以通过让这两个类隶属不同的包来相互区分。
定义包
创建一个包的语法格式是：package 包名(或包路径);
package nuc.ss.demo;
public class Student {
…
}
注意：
（1）一个.java文件只能有一个package语句；
（2）声明包的语句要写在源程序文件的第一行（注释除外）
引入包
当一个类需要使用其他包中的类时，通常需要将其引入（或导入）本类之中。
引入包的语法：
import nuc.sw.model.Student;
其中： nuc.sw.model 称为包名（或包路径），它告知编译器与虚拟机：要导入的类来自哪个包。
在引入包路径的语法中可以使用*通配符，指包路径下所有类。
import nuc.sw.model.*;
一个源文件中可以有多个import语句，他们必须在package和类的之间。
包作用域
包路径是解决类命名冲突的问题。另外，包还可以作为作用域，有一个专门的访问限制修饰符与包路径有关：
缺省访问修饰符
缺省修饰符就是在成员变量与成员方法前什么修饰符号都不添加。
缺省修饰符就是只能在同一个包路径内访问。
package com.oracle.ptb;
public class ClsA{
int m_a=30;
}
package com.oracle.ptb;
public class ClsB{
public static void main(String[] ar)
{
ClsA obja=new ClsA();
obja.m_a=40; //你改改包路径试下？
}
}
java中常用的包
java语言中最常用的4个系统包
java.lang=>基础语言类
java.util=>工具包，包含数据结构类
java.io=>输入输出类
java.sql=>数据库操作类
Java.lang包是Java语言的核心类库，它包含了运行Java程序必不可少的系统类，系统自动为程序引入java.lang包中的类（比如System类、Math类等）
如果要使用其它包中的类，必须要引入包
小结
包
1、定义包
package 包名;
2、引入包
import 包名.类名; 或import 包名.*;
3、包作用域
缺省修饰符就是只能在同一个包路径内访问。
4、Java中最常用的包
Java.lang包是Java语言的核心类库，它包含了运行Java程序必不可少的系统类，系统自动为程序引入java.lang包中的类（比如System类、Math类等）
如果要使用其它包中的类，必须要引入包。
String类
String类, 又称为字符串类。
String类不是Java的基本数据类型。
String类可对字符串进行拼接、编辑、比较等操作。
字符串类的实例（字符串对象）一旦创建就不能再做修改，即String类是属于immutable（不可修改的）。对字符串的拼接、编辑等操作会产生String类的一个新的实例（即新的字符串）。
StringBuffer/StringBuilder类
它们都可以用来对字符串本身进行直接编辑、修改。
StringBuffer类是线程安全的，StringBuilder类是线程不安全的
创建字符串
创建字符串的语法：
String str1 = "Oracle"; //第一种构建方式
String str2 = new String("Oracle"); //第二种构建方式
第一种构建方式：创建了一个“Oracle”常量，使用str1引用该常量。
第二种构建方式：创建了一个对象，并对对象赋 “Oracle”字符串值，使用str2引用该对象。
字符串拼接
拼接字符串：
可以使用“+”将两个字符串拼接在一起组成一个新字符串。
String str1 = "CSG";
String str2 = new String("Oracle");
String str3 = str1 + "-" + str2;
//输出结果为：CSG-Oracle
“+”所在表达式的左右只要有一侧为字符串，则“+”的作用就演变为字符串拼接，至于另一侧是什么类型并不重要。
如果“+”左右两侧都不是字符串，而是数值类型，则“+”演变为数值加计算。
获取字符串信息
获取字符串长度：
String类提供了length方法用于获取字符串的长度。
length方法以Unicode编码格式获取字符长度，因此无论是英语还是中文单个字符的长度始终为1。
原型：public int length()
String str1 = "CSG-甲骨文";
System.out.println(str1.length()); //输出结果为7
获取字符串指定位置的字符：
String类提供了charAt方法用于获取字符串中的某个字符。
获取字符（或子串）在字符串中的位置：
String类提供了indexOf方法与lastIndexOf方法用于获取某个字符或子串在字符串中的第一次出现的位置与最后一次出现的位置（大小写敏感）。
原型: public int indexOf(String str)
public int lastIndexOf(String str)
String str1 = "csg-Oracle";
System.out.println(str1.indexOf("c")); //结果为0
System.out.println(str1.lastIndexOf("c")); //结果为7
System.out.println(str1.lastIndexOf("C"));
//结果为-1 （找不到返回-1）
编辑字符串
去除字符串中的空格：
String类的trim方法用于去除字符串左侧与右侧的空格。
原型：public String trim()
String str1 = = " CSG - 甲骨文 ";
System.out.println(str1.trim());
//结果为CSG - 甲骨文
替换字符串：
String类的replaceAll方法用于将字符串中的指定字符替换成其他字符。
原型：public String replaceAll(String regex, String replacement)
String str1 = "csg-Oracle";
System.out.println(str1.replaceAll("csg", "CSG")); //输出结果为CSG-Oracle
字符串的比较
相等判断：
多个String对象之间的数据对比在项目开发过程中是非常常用的。
“”运算符不能用于String对象数据间的对比。
提示：对象在通过“”运算符对比时，比的是对象地址而不是数据。
String对象提供了equals方法用于对象数据间的对比。
原型：public boolean equals(Object anObject)
写出下面输出语句的输出结果。
String str1 = “CSG-甲骨文”;
String str2 = “CSG-甲骨文”;
String str3 = new String(“CSG-甲骨文”);
String str4 = new String(“CSG-甲骨文”);
System.out.println(str1 == str2); //true
System.out.println(str1 == “CSG-甲骨文”); //true
System.out.println(str3.equals(“CSG-甲骨文”)); //true
System.out.println(str3 == str4); //false
System.out.println(str3 == str1); //false
原因：第一种构造字符串的方法和下面的第二种构造方法的区别是第二种构造的办法创建了对象，两个对象之间的CSG-甲骨文是一样的，其实他们的存储地址是不同的，无论是栈内存和堆内存都不相同，而且哈希值都不同。
StringBuffer类
String对象一旦产生后就不可以被修改，重新赋值其实是两个对象。
StringBuffer对象的内容可以修改；在进行字符串处理时，不生成新的对象，在内存使用上要优于String类。
在实际使用时，如果经常需要对一个字符串进行修改，例如插入、删除等操作，使用StringBuffer要更加适合一些。
效率更高。
修改字符串的功能更强大。
构建StringBuffer对象的语法:
原型：public StringBuffer(String str)
StringBuffer buffer = new StringBuffer("");
StringBuffer拼接字符串：
StringBuffer提供了功能强大，效率更高的字符串拼接方法append。
原型：public StringBuffer append(Object obj)
buffer.append("CSG").append("-").append("Oracle");
相对于“+”运算符，append性能更高。
相对于“+”运算符，append对于内存消耗更低。
StringBuffer修改字符串：
在指定位置插入一个字符：
原型：public StringBuffer insert(int offset, String str)
删除指定位置的一个字符
原型： public StringBuffer deleteCharAt(int index)
buffer.append("CSG").append("-").append("Oracle");
System.out.println(buffer.toString());
//结果为：CSG-Oracle
buffer.insert(0, "[");
buffer.insert(4, "]");
buffer.deleteCharAt(5);
System.out.println(buffer.toString());
//结果为[CSG]Oracle
包装类
包装类概述
包装类简介：
“包装”的作用是将一个功能较弱、能力较差的组件或类型，经过一组特殊的处理变的功能更强大。
“包装” 的优点是：不会“损坏”被包装组件的原始功能，而是叠加功能。
Java中的基本包装类：
Java是一种面向对象的编程语言，即“万事万物皆对象”。
Java语言唯独8种原始数据类型不是对象（int、float、double……）。
从JDK1.5开始，引入了包装类，通过使用包装类，可以将基本数据类型值作为对象处理。而且允许基本数据类型与对应的包装类之间进行自动转换。
基本数据类型与包装类
基本数据类型 包装类
int java.lang.Integer
char java.lang.Character
float java.lang.Float
double java.lang.Double
byte java.lang.Byte
short java.lang.Short
long java.lang.Long
构造方法
使用基本数据类型值来构造包装类对象
原型：public Integer(int value)
public Float(float value)
Integer in = new Integer(10);
Float ft = new Float(10.2f);
使用表示数值的字符串来构造包装类对象
原型：public Integer(String value)
public Float(String value)
Integer in = new Integer("10");
Float ft = new Float("10.2f");
注意：如果传入的是非数字字符串，将引发异常。
数值包装类中的两个常量
两个常量
MAX_VALUE：表示对应的基本数据类型的最大值。
MIN_VALUE：表示对应的基本数据类型的最小值。（对于Float类和Double类而言，表示最小正值）
System.out.println("最大整数为："
+ Integer.MAX_VALUE);
System.out.println("最小整数为："
+ Integer.MIN_VALUE);
System.out.println("单精度浮点数的最小正值为："
+ Float.MIN_VALUE);
System.out.println("双精度浮点数的最大值为："
+ Double.MAX_VALUE);
返回包装对象对应的基本数据类型值
每个数值包装类都提供了一组方法，用于返回包装对象对应的基本数据类型值。
原型： public byte byteValue()
public short shortValue()
public int intValue()
public long longValue()
public double doubleValue()
public float floatValue()
new Integer(12).doubleValue() // 返回 12.0
new Float(12.4f).intValue() // 返回 12
数值包装类的静态方法valueOf
用来创建一个新对象，并将它初始化为指定字符串表示的值。
原型：public static Integer valueOf(String s)
public static Integer valueOf(String s, int radix)
public static Float valueOf(String s)
public static Float valueOf(String s, int radix)
Integer in = Integer.valueOf("10");
Integer in = Integer.valueOf("10", 2);
Float ft = Float.valueOf("10.2f");
Float ft = Float.valueOf("1A.2f", 16);
Integer i = Integer.valueOf("9999999");
System.out.println(i.byteValue());//输出结果为:127
将数值字符串转换为基本数据类型值
原型：public static int parseInt(String s)
public static int parseInt(String s, int radix)
public static float parseFloat(String s)
public static float parseFloat(String s, int radix)
Integer.parseInt("835") // 返回 835
Integer.parseInt("1001", 2) // 返回 9
Float.parseFloat("13.5f") // 返回 13.5
Integer.parseInt("12.5") // 引发运行时异常
Integer.parseInt("12", 2) // 引发运行时异常
自动装箱与拆箱
自动装箱与拆箱的概念：
装箱（boxing）：是指将基本类型值转换为包装类对象的过程。
拆箱（unboxing）：将包装对象转换为基本类型值。
Java允许基本类型和包装类类型之间自动转换：
如果一个基本类型值出现在需要对象的环境中，编译器会将基本类型值进行自动装箱；
如果一个包装类对象出现需要基本类型值的环境中，编译器会将包装类对象进行自动拆箱。
Integer intObject = 100;
// 等价于 Integer intObject = new Integer(100);
int i = intObject; // 等价于 int i = 100;
例六
自动装箱与拆箱数据测试：写出下面输出语句的输出结果。
Integer i = 100;
Integer j = new Integer("100");
System.out.println(i == j); //结果为false，因为j与i都是对象
System.out.println(i == 100);//结果为true，因为表达式的一端为数值型，JVM自动 将i对象转换为数据类型，不会用对象方式对比
总结
OOP基本特征
1、抽象
将问题域中具有相同属性和行为的若干对象抽象为类。
2、封装
将有关的数据及操作代码封装在一个对象之中，确保数据安全。
3、继承
通过继承机制，方便地扩展已有的类，实现代码复用。
4、多态
包括操作名称的多态（通过方法重载体现）和与继承有关的多态。
类
1、实现类
包括类的声明和类体，而类体由成员变量和成员方法构成。类名的命名规范。
2、类的成员变量
类型任意、位置任意，系统提供默认初值，在类内可以直接使用，类外如何访问呢？成员变量的命名规范。
3、类的成员方法
类型任意、位置任意，定义格式与C语言函数类似。在类内可以直接调用，类外如何调用呢？成员方法的命名规范。
4、成员的修饰符
private、缺省、protected、private；
从数据安全和使用方便考虑，建议成员变量用private修饰；对外提供使用的成员方法用public修饰。
为每一个使用private修饰的成员变量提供setter和getter，命名规范？
static
使用static修饰的成员称为全局成员；
可以通过类名直接访问全局成员。
5、方法重载
一个类中可以有多个方法具有相同的名字，它们的参数不同（个数、类型），这种现象称为方法重载，这些方法就叫重载方法；
Java编译器将根据方法名和参数确定调用哪一个方法。（方法的识别与方法的返回值类型无关）
方法重载是多态性的一种体现（即操作名称的多态）。
6、this关键字
用于调用类中的其他构造方法；
用于代表类中所产生的那个对象，主要解决成员变量名与成员方法的局部变量名的命名冲突问题。this等同于作用域。
7、构造方法
作用：用于创建对象，包括为对象分配内存和提供对成员变量的初始化；
构造方法的特殊性： （与一般的成员方法的区别）
关于方法名
关于返回值类型
如何调用？
用户是否必须定义构造方法？
UML简介及UML类图
1、UML简介
全称：Unified Modeling Language，统一建模语言；
能很好地表达软件设计中的静态和动态信息，支持包括面向对象需求分析、设计、编码、测试在内的软件开发的全过程。
本课程主要使用UML来描述软件系统中的类以及类间的关系，是软件系统建模的工具。
2、UML类图
三层结构：名字层、变量层和方法层。
成员访问修饰符的表示
UML简介及UML类图
3、UML类图中的关联关系
如果A类中成员变量是用B类来声明的变量，那么A和B的关系是关联关系，称A关联于B。
4、 UML类图中的依赖关系
如果A类中某个方法的参数是用B类来声明的变量或某个方法返回的数据类型是B类型的，那么A和B的关系是依赖关系，称A依赖于B。
5、 UML类图中的泛化关系（即继承关系）
6、 UML类图中的实现关系
如果一个类实现了一个接口，那么类和接口的关系是实现关系，称类实现接口。
对象
类与对象的关系
在分析阶段，类是对具有相同属性和共同行为的一组对象的抽象；
在设计阶段，类又是创建对象的模板，相应地，对象也称为类的实例。
1、声明对象
与声明变量一样。例如：Student stu1;
2、创建对象
使用new运算符调用类的构造方法来创建该类的对象。
例如：
stu1 = new Student(17006, “张三”);
或
Student stu2 = new Student(17007, “李四”, 96,true);
理解：
创建对象本质上要做两件事；
栈内存（存放引用变量）和堆内存（存放对象本身）。
3、成员变量的初始化
声明的同时，直接提供初值；
创建对象时调用构造器对成员变量进行初始化；
创建对象之后通过对象调用成员方法进行初始化。
4、初始化块（了解）
又称静态匿名块，用来对全局成员进行初始化；
最先执行的代码（先于构造方法调用）。
5、使用对象
通过对象访问该对象的成员变量；
例如： stu1.name; (受限于成员变量的修饰符)
通过对象调用该对象的成员方法。
例如：stu1.print();
6、析构器与对象释放（了解）
对象不再使用时应该释放；
谁来释放？ JVM中的垃圾回收器；
什么时候回收？具体时间不确定；
垃圾回收器在释放对象之前会调用一个特殊的方法，即析构方法（或称析构器）： protected void finalize()；
对象的组合
1、什么是对象的组合
一个类的成员变量可以是另一个类的对象，换言之，一个类可以把另一个类的对象作为自己的成员变量；
如果用这样的类创建对象，那么该对象中就会有其他对象。也就是说，该对象将其他对象作为自己的组成部分。这就是对象的组合。
2、案例
计算一个圆柱体的体积。
主要定义了：圆类、圆柱体类。圆柱体类的一个成员变量是用圆类声明的对象（作为圆柱体的底部）。
包
理解：为什么要使用包？
1、定义包
语法格式： package 包名;
2、引入包
语法格式：
import 包名.类名; 或者
import 包名.*;
3、包作用域
使用缺省修饰符的成员只能在同一个包路径内访问。
本质上，包代表作用域，用来解决类命名冲突问题。
补充说明：定义一个类的时候，也可以访问修饰符，但通常只能是public或缺省。（如果是内部类，则可以使用private）
4、Java中最常用的包
java.lang(基本语言类，包括System类、Math类等，由系统自动导入)，java.util，java.io，java.sql等。
string类
1、创建字符串
方式一： String str1 = “Oracle”;
方式二： String str2 = new String(“Oracle”);
2、字符串拼接（连接）
使用“+”运算符。
3、获取字符串信息
获取字符串的长度
使用String类的length()方法。
获取字符串指定位置的字符
使用String类的charAt()方法。
获取字符串中的部分内容（子串）：
public String substring(int beginIndex)
public String substring(int beginIndex, int endIndex)
4、字符串的编辑
去掉字符串中左右两侧的空格
使用String类的trim方法。
替换字符串：
使用String类的replaceAll方法。
5、字符串的比较—相等判断：
使用String类的equals方法，比较当前对象与给定对象的数据是否相等；
而“==” 用于比较两个对象的地址是否相等。
6、StringBuffer类
StringBuffer对象的内容可以修改；在进行字符串处理时，不生成新的对象，在内存使用上要优于String类。
而String对象一旦产生后就不可以被修改，重新赋值其实是两个对象。
如果经常需要对一个字符串进行修改，例如插入、删除等操作，使用StringBuffer要更加适合一些。
例如：
StringBuffer buffer = new StringBuffer(“”);
buffer.append(“CSG”).append(“-”).append(“Oracle”);
buffer.insert(0, “[”); buffer.insert(4, “]”);
buffer.deleteCharAt(5);
System.out.println(buffer.toString());
课后习题
单选题
对于下列Dog类,哪个叙述是错误的?
class Dog {
Dog(int m){ }
Dog(double m){ }
int Dog(int m){
return 23; }
void Dog(double m){
}
}
- A. Dog(int m)与Dog(double m)互为重载的构造方法。
- B. int Dog(int m)与void Dog(double m)互为重载的非构造方法。
- C. Dog类只有两个构造方法,而且没有无参数的构造方法。
- D. Dog类有3个构造方法。
正确答案: D
有两个构造方法
构造方法有两种
使用基本数据类型值来构造包装类对象
使用表示数值的字符串来构造包装类对象
这里是使用了基本数据类型来构造的Dog(int m)与Dog(double m)
当用new运算符和构造方法创建对象时,下列哪个步骤的叙述是正确的?
A.①为成员变量分配内存,并指定默认值。
②初始化成员变量,即用户声明成员变量时给定的默认值。
③执行构造方法。
④计算出一个引用值。
B.①计算出一个引用值。
②为成员变量分配内存,并指定默认值。
③初始化成员变量,即用户声明成员变量时给定的默认值。
④执行构造方法。
C. ①执行构造方法。
②为成员变量分配内存,并指定默认值。
③初始化成员变量,即用户声明成员变量时给定的默认值。
④计算出一个引用值。
D.①为成员变量分配内存,并指定默认值。
②初始化成员变量,即用户声明成员变量时给定的默认值。
③计算出一个引用值。
④执行构造方法。
正确答案: A
对于下列Tom类，哪个叙述是正确的？
public class Test {
public static void main(String args[]){
Tom cat = new Tom(); }}
class Tom {
void Tom(){
System.out.println(“ok”); }
Tom(int m){
System.out.println(“你好”); }}
- A. 程序运行时输出：ok。
- B. 没有构造方法。
- C. 有编译错误，因为创建对象cat使用的不是构造方法，java编译器已经不提供默认的构造方法了。
- D. 程序运行时无任何输出。
正确答案: C
下列哪个叙述是正确的?
- A. 成员变量有默认值。
- B. this可以出现在static方法中。
- C. 类中的实例方法可以用类名调用。
- D. 局部变量也可以用访问修饰符:public,proteced,private修饰。
正确答案: A
成员变量如果没有初始化，编译器会自动初始化成缺省值。
this无法出现在static修饰的方法中，因为static修饰的方法是属于类的，该方法的调用者可能不是一个类，而不是对象
类方法能够用类名调用，而实例办法只能通过对象调用
修饰符没有proteced而是 protected
下列哪个叙述是正确的?
- A. 源文件可以有2条包语句(package)。
- B. 源文件不可以有多条import语句。
- C. 如果源文件有package语句,该语句也可以是源文件的第2条语句。
- D. 类中的类方法(static方法)只能操作类变量(static变量),不可以操作实例变量。
正确答案: D
源文件不可以有2条包语句(package)。但是可以有多条import语句
如果源文件有package语句,该语句只能放到源文件的第一句
下列源文件中,分别由1、2、3、4注释标注的哪行代码有错误?
class E {
int x;
public void f(int n) {
int m; // 1
int t = x+n; // 2
int y = x+m; // 3
m = 10;
y = x+m; // 4 } }
- A. 1
- B. 2
- C. 3
- D. 4
正确答案: C
下列源文件中,分别由1、2、3、4注释标注的哪行代码有错误?
public class People {
int m = 10,n; // 1
n = 200; // 2
void f(){
if(m == n)
n += m; // 3
else
n = n - m; // 4 }}
- A. 1
- B. 2
- C. 3
- D. 4
正确答案: B
在 Java 中，由Java编译器自动导入，而无需在程序中用import导入的包是（ ）。
- A.java.applet
- B. java.awt
- C. java.util
- D. java.lang
正确答案: D
这里看上面java中常用的包
为B类的一个无形式参数无返回值的方法method书写方法头，使得使用类名B作为前缀就可以调用它，该方法头的形式为（ ）。
- A.static void method()
- B.public void method()
- C.final void method()
- D.abstract void method()
用类方法static来调用
类与对象的关系是( )
- A. 类是对象的抽象
- B. 对象是类的抽象
- C. 对象是类的子类
- D. 类是对象的具体实例
正确答案: A
对于一个Java源文件,import, class定义以及package正确的顺序是
- A. package,import,class
- B. class,import,package
- C. import,package,class
- D. package,class,import
正确答案: A
包肯定在前面，下来是import导入包，最后是定义class
构造方法何时被调用( )
- A. 类定义时
- B. 创建对象时
- C. 调用对象方法时
- D. 使用对象的变量时
正确答案: B
下面选项中哪个方法不是方法public int max(int x,int y)的重载方法。
- A. public double max(double x,double y)
- B. public int max(int n,int k)
- C. public int max(int x,int y,int z)
- D. public double max(double n,double k,double l)
正确答案: B
B就一样了
在Java中,一个类可同时定义许多同名的方法,这些方法的形式参数的个数、类型或顺序各不相同,传回的值也可以不相同,这种面向对象程序特性称为( )
- A. 隐藏
- B. 覆盖
- C. 重载
- D. Java不支持此特性
正确答案: C
表示数据或方法只能被定义它的类访问的修饰符是( )
- A. public
- B. 缺省
- C. private
- D. protected
正确答案: C
下面是一个有关计算盒子体积的程序，请将程序补充完整。
import ; //（1）
public class MainClass_BoxVolume
{
public static void main(String[] args)
{
; //(2)
box.inputInfo();
; //(3)
}
}
class Box
{
int length;
int width;
int height;
public void inputInfo()
{
System.out.println("Please input box's length,width,height:");
; //(4)
length=sc.nextInt();
width=sc.nextInt();
height=sc.nextInt();
}
public void getVolume()
{
System.out.println("box's volume is:"+length*width*height);
}
}
正确答案：
(1) java.util.Scanner
(2) Box box = new Box()
(3) box.getVolume()
(4) Scanner sc = new Scanner(System.in)
java.util.Scanner主要功能是简化文本扫描、获取控制台输入。
下面是一个有关计算学生本学期各门功课总分和均分，并输出学生信息的程序，请将程序补充完整。
import java.util.Scanner;
public class StudentInfor {
public static void main(String[]args) {
Student stu=new Student();
stu.inputInfo();
stu.printInfo();
}
}
//（1）{
int number;
String name;
String course[]={"java","离散数学","大学英语","中国近代史纲要","高数","大学物理"};
float score[];
float sum=0,ave;
public void inputInfo() {
Scanner reader=new Scanner(System.in);
System.out.println("请进入该同学的基本信息：");
System.out.print("学号：");
number=reader.nextInt();
System.out.print("姓名：");
name=reader.next();
; //（2）score 数组的创建
for(int i=0;i<course.length;i++) {
System.out.println(course[i]+"成绩：");
; //（3）score 数组元素的初始化
}
}
public float getSum() {
for(int i=0;i<course.length;i++)
; //（4）
return sum;
}
public float getAve() {
; //（5）
return ave;
}
public void printInfo() {
System.out.println("该同学的基本信息为：");
System.out.println("学号："+number);
System.out.println("姓名："+name);
System.out.println("总分："+getSum());
System.out.println("均分："+getAve());
}
}
正确答案：
(1) class Student
(2) score = new Float[course.length];score = new Float[6]
(3) score[i] = reader.nextFloat()
(4) sum += score[i];sum = sum + score[i]
(5) ave = sum / score.length;ave = sum / course.length;ave = sum / 6
判断题
类是最重要的“数据类型”,类声明的变量被称为对象变量,简称对象。( )
- A. 对
- B. 错
正确答案: 对
构造方法没有类型。( )
- A. 对
- B. 错
正确答案: 对
类中的实例变量(不被static修饰的成员变量)在用该类创建对象的时候才会被分配内存空间。( )
- A. 对
- B. 错
正确答案: 对
类中的实例方法可以用类名直接调用。( )
- A. 对
- B. 错
正确答案: 错
*答案解析：*类中的实例方法是不被static修饰的方法,总有被static 修饰的方法才能用类名直接调用。
局部变量没有默认值。( )
- A. 对
- B. 错
正确答案: 对
*答案解析：*在Java中,成员变量会赋初值(默认值),局部变量没有默认值,需要初始化后才能使用。
方法中声明的局部变量不可以用访问修饰符:public,proteced,private修饰。( )
- A. 对
- B. 错
正确答案: 对
*答案解析：*在Java中,只有成员变量和成员方法才可以用访问修饰符:public,proteced,private修饰。
this可以出现在实例方法和构造方法中。( )
- A. 对
- B. 错
正确答案: 对
成员变量的名字不可以和局部变量的相同。( )
- A. 对
- B. 错
正确答案: 错
static方法不可以重载。( )
-
A. 对
-
B. 错
for(int i=0;i<course.length;i++) { System.out.println(course[i]+"成绩："); ; //（3）score 数组元素的初始化 }}
public float getSum() {
for(int i=0;i<course.length;i++) ; //（4） return sum;}
public float getAve() {
; //（5） return ave;}
public void printInfo() {
System.out.println(“该同学的基本信息为：”);
System.out.println(“学号：”+number);
System.out.println(“姓名：”+name);
System.out.println(“总分：”+getSum());
System.out.println(“均分：”+getAve());
}
}
正确答案：
(1) class Student
(2) score = new Float[course.length];score = new Float[6]
(3) score[i] = reader.nextFloat()
(4) sum += score[i];sum = sum + score[i]
(5) ave = sum / score.length;ave = sum / course.length;ave = sum / 6
### 判断题
类是最重要的“数据类型”,类声明的变量被称为对象变量,简称对象。( )
- A. 对
- B. 错
*正确答案:* 对
构造方法没有类型。( )
- A. 对
- B. 错
*正确答案:* 对
类中的实例变量(不被static修饰的成员变量)在用该类创建对象的时候才会被分配内存空间。( )
- A. 对
- B. 错
*正确答案:* 对
类中的实例方法可以用类名直接调用。( )
- A. 对
- B. 错
*正确答案:* 错
*答案解析：*类中的实例方法是不被static修饰的方法,总有被static 修饰的方法才能用类名直接调用。
局部变量没有默认值。( )
- A. 对
- B. 错
*正确答案:* 对
*答案解析：*在Java中,成员变量会赋初值(默认值),局部变量没有默认值,需要初始化后才能使用。
方法中声明的局部变量不可以用访问修饰符:public,proteced,private修饰。( )
- A. 对
- B. 错
*正确答案:* 对
*答案解析：*在Java中,只有成员变量和成员方法才可以用访问修饰符:public,proteced,private修饰。
this可以出现在实例方法和构造方法中。( )
- A. 对
- B. 错
*正确答案:* 对
成员变量的名字不可以和局部变量的相同。( )
- A. 对
- B. 错
*正确答案:* 错
static方法不可以重载。( )
- A. 对
- B. 错
*正确答案:* 错