JavaSE_面向对象1

1、课程名称：面向对象（基础）
2、知识点
2.1、上次课程的主要知识点
1、 两个环境变量
• PATH：设置JDK的操作指令的环境
• CLASSPATH：设置类的路径， java执行的时候要找到classpath，之后找到对应的class文件
2、 Java的数据类型：
• 基本数据类型：
|- 数值型：
|- 整数：byte、short、int、long
|- 浮点型：float、double
|- 字符型：char
|- boolean型：boolean
• 引用数据类型：数组、类、接口
• 一个整数的默认类型是int，一个小数的默认类型是double
3、 关键字的
• 未使用到的关键字：const、goto
• JDK 1.4增加的关键字：assert
• JDK 1.5增加的关键字：enum
4、 方法的概念
• 方法就是可重复调用的一段代码段
• 方法的声明格式，（当前讲可以由主方法直接调用）：public static 返回值类型 方法名称(参数列表){}
• 返回值类型：可以是任意的数据类型，包括基本和引用
• 递归调用：自己调用自己，但是必须有结束条件
5、 数组
• 数组就是一组相关变量的集合，通过下标访问数组
• 数组的定义格式：
|- 动态初始化：数据类型 数组名称[] = new 数据类型[长度] ;
|- 静态初始化：数据类型 数组名称[] = {值, 值, 值, 值, 值} ;
• 数组本身属于引用数据类型，所以需要进行栈和堆的划分，之前也简单的演示了的栈-堆的分配问题。
• Java中提供了System.arraycopy()完成数组复制，和java.util.Arrays.sort()完成数组排序
2.2、本次预计讲解的知识点
1、 介绍面向对象的基本概念
2、 类与对象的关系
3、 对象的引用传递及内存分配问题
4、 类的封装性
5、 构造方法和匿名对象
6、 建立类的开发思路
7、 String类的特点及操作方法
3、具体内容
3.1、面向对象
此概念如果直接去解释的话可能会比较抽象，因为大家缺少对原始的面向过程的开发语言的了解。
面向过程是很难适应变化的，而面向对象因为有其完整的分析思路，所以可以任意的进行修改。
面向对象从概念上讲分为以下三种：OOA、OOD、OOP
|- OOA：面向对象分析(Object Oriented Analysis)
|- OOD：面向对象设计 (Object Oriented Design)
|- OOP：面向对象程序 (Object Oriented Promgramming)
但是，我们在学习中并不会严格的按照以上的步骤走，我们的分析和解决问题的思路来源于现实生活。
面向对象中有三大特征：
• 封装性：所有的内容对外部不可见
• 继承性：将其他的功能继承下来继续发展
• 多态性：方法的重载本身就是一个多态性的体现
问答：你如何理解面向对象？
面向对象是当今主流的一种程序设计理念和设计规范，它取代了早期的”结构化”过程设计开发技术，主张一切皆为对象，程序以人的思维模式去解决问题。面向对像的程序是由类组成的，每个类包含对用户公开的特定功能部分和隐藏的实现部分。传统的结构化程序设计通过设计一系列的过程（即算法）来求解问题。这一些过程一旦被确定，就要开始考考虑存储数据的方式，这就明确的表述了程序员的工作方式。但面相对像却调换了这个顺序，它不必关心数据对象的具体实现，只要能满足用户的需求即可。面向对象有三个最基本的特性，即：封装，继承，多态。

封装（Encapsulation）:使用方法把类的数据隐藏起来，遵循了java 一切皆为对象的基本概念和核心思想，达成对类的封装，让普通类型上升为对象级；封装控制用户对类的修改和访问数据的程度，增强了程序的可维护性。

继承（Implementation）:发生在类和类之间，可分为单继承和多层继承描述父子对象之间的血缘关系， 最终达到的目的是：一旦使用了继承，子类便获得了父类所有的成员（变量和方法），但是父类的私有的方法和属性不能被访问，父类的final成员不能被重写。 一旦使用了继承，父类的实例能指向派生类（子类）的引用。

多态（Multipart）:对象在运行期和编译期具有的两种状态，使代码具有灵活性和重用性。编译时多态，也就是函数重载，所谓函数重载就是指同一个函数名可以对应多个函数的实现具体调用哪个按照由参数个数，参数类型等来决定。运行时多态：用一个基类的指针或引用来操纵多个派生类型的能力被称为多态性。

3.2、类与对象
3.2.1、两者的关系
在面向对象的概念中类和对象是一个绝对的重点问题，下面就要分析类和对象的关系。
类表示一个共性的产物，是一个综合的特征，而对象，是一个个性的产物，是一个个体的特征。
类必须通过对象才可以使用，那么对象的所有操作都在类中定义。
类由属性和方法组成：
• 属性：就相当于一个个的特征
• 方法：就相当于人的一个个的行为，例如：说话、吃饭、唱歌、睡觉
3.2.2、类的定义格式
在Java中可以使用以下的语句定义一个类：
class 类名称{
属性名称
方法名称(){}
}
但是，在定义类的时候类中的方法声明时，可以暂时不加入public static，而只写返回值类型和方法名称。
下面按照以上的格式定义出一个Person类
class Person{
String name ; // 表示姓名
int age ; // 表示年龄
void tell(){
System.out.println(“姓名：” + name + “；年龄：” + age) ;
}
};
以上定义出了一个类，但是这个类要想被使用，则必须依靠对象。
3.2.3、对象的定义格式
一个类要想真正的进行操作，则必须依靠对象，对象的定义格式如下：
类名称 对象名称 = new 类名称() ;
按照以上的格式就可以产生对象了。
如果要想访问类中的属性或方法（方法的定义），则可以依靠以下的语法形式：
访问类中的属性： 对象.属性 ;
调用类中的方法： 对象.方法() ;
范例：调用Person类中的属性和方法
class Person{
String name ; // 表示姓名
int age ; // 表示年龄
void tell(){
System.out.println(“姓名：” + name + “；年龄：” + age) ;
}
};
public class OODemo02{
public static void main(String args[]){
Person per = new Person() ; // 声明对象并实例化
per.name = “张三” ; // 设置per对象的name属性内容
per.age = 30 ; // 设置per对象的age属性内容
per.tell() ; // 调用类中的方法
}
};
此时，所有的操作已经正常的调用完成，而且一个类可以使用了，但是以上的操作有以下几点必须说明。
• 在java中对象声明有两种含义
|- 声明对象：Person per = null ; // 表示声明了一个对象，但是此对象无法使用，per没有具体的内存指向
|- 实例化对象：per = new Person() ; // 表示实例化了对象，可以使用
public class OODemo03{
public static void main(String args[]){
Person per = null ; // 声明对象
per = new Person() ; // 实例化对象
per.name = “张三” ; // 设置per对象的name属性内容
per.age = 30 ; // 设置per对象的age属性内容
per.tell() ; // 调用类中的方法
}
};
• 对象属于引用数据类型，所以也需要进行内存的划分。
|- 不管任何情况下，只要是调用了关键字new，则表示开辟新的堆内存空间


所以在使用类的时候必须考虑到堆-栈的引用空间，但是在这里有一个需要说明的问题：
• 如果一个类中没有使用关键字new进行内存的开辟，则将出现以下的问题：
Exception in thread “main” java.lang.NullPointerException
at OODemo03.main(OODemo03.java:12)
出现了“空指向”问题，那么此问题将陪伴大家的开发人生。造成此类问题的根源非常简单，因为没有开辟对应的堆内存空间，所以出现以上的错误。
那么，如果现在产生多个对象呢？这些对象之间会不会互相影响呢？
public class OODemo04{
public static void main(String args[]){
Person per1 = null ; // 声明对象
Person per2 = null ; // 声明对象
per1 = new Person() ; // 实例化对象
per2 = new Person() ; // 实例化对象
per1.name = “张三” ; // 设置per对象的name属性内容
per1.age = 30 ; // 设置per对象的age属性内容
per2.name = “李四” ;
per2.age = 33 ;
per1.tell() ;
per2.tell() ; // 调用类中的方法
}
};
以上的程序，可以得出以下的内存关系图


提问：在类的操作中，所有的对象名称放在栈内存中，所有的对象的具体内容放在堆内存之中，那么类中的方法放在那里了？
实际上所有的方法放在了全局代码区中。
那么，对象间既然属于引用数据类型的操作，所以肯定也是可以进行引用传递的，如果要想进行引用传递，就是将一个堆内存的空间地址的使用权给了其他对象。
class Person{
String name ; // 表示姓名
int age ; // 表示年龄
void tell(){
System.out.println(“姓名：” + name + “；年龄：” + age) ;
}
};
public class OODemo05{
public static void main(String args[]){
Person per1 = null ; // 声明对象
Person per2 = null ; // 声明对象
per1 = new Person() ; // 实例化对象
per1.name = “张三” ; // 设置per对象的name属性内容
per1.age = 30 ; // 设置per对象的age属性内容
per2 = per1 ; 将per1对象的堆内存空间给了per2，那么此时的内存关系图
per2.name = “李四” ;
per1.tell() ;
per2.tell() ; // 调用类中的方法
}
};

继续观察以下的一种情况：
class Person{
String name ; // 表示姓名
int age ; // 表示年龄
void tell(){
System.out.println(“姓名：” + name + “；年龄：” + age) ;
}
};
public class OODemo05{
public static void main(String args[]){
Person per1 = null ; // 声明对象
Person per2 = null ; // 声明对象
per1 = new Person() ; // 实例化对象
per2 = new Person() ; // 实例化对象
per2.name = “王五” ;
per1.name = “张三” ; // 设置per对象的name属性内容
per1.age = 30 ; // 设置per对象的age属性内容
per2 = per1 ;
per2.name = “李四” ;
per1.tell() ;
per2.tell() ; // 调用类中的方法
}
};

从本道程序之中，可以清楚的发现垃圾对象的产生，垃圾对象将被系统通过GC进行自动的垃圾回收，并释放掉内存空间。
3.3、封装性（重点）
在讲解封装性之前，来看一下以下的代码：
class Person{
String name ; // 表示姓名
int age ; // 表示年龄
void tell(){
System.out.println(“姓名：” + name + “；年龄：” + age) ;
}
};
public class OODemo07{
public static void main(String args[]){
Person per = new Person() ;
per.name = “张三” ;
per.age = -30 ;
per.tell() ;
}
};
以上的操作代码并没有出现了语法错误，但是出现了逻辑错误。那么此时，这种操作并不是很合乎正常的逻辑。
造成此类问题的根源在与，可以通过对象直接访问类中的属性。那么，此时就需要对类中的内容进行封装，使用private关键字，使用之后的效果如下：
class Person{
private String name ; // 表示姓名
private int age ; // 表示年龄
void tell(){
System.out.println(“姓名：” + name + “；年龄：” + age) ;
}
};
public class OODemo08{
public static void main(String args[]){
Person per = new Person() ;
per.name = “张三” ;
per.age = -30 ;
per.tell() ;
}
};
编译时出现了以下的错误提示：
OODemo08.java:11: name has private access in Person
per.name = “张三” ;
^
OODemo08.java:12: age has private access in Person
per.age = -30 ;
^
2 errors
name和age属性是私有的访问权限，不能被外部所访问，那么此时，既然不能被外部所访问，则肯定是安全的了。
所以，在Java开发中对于所有的私有属性要想进行访问，必须通过setter和getter方法，这是一个标准的操作，例如：
• 现在有String name属性
• setter：public void setName(String str)
• getter：public String getName()
class Person{
private String name ; // 表示姓名
private int age ; // 表示年龄
void tell(){
System.out.println(“姓名：” + getName() + “；年龄：” + getAge()) ;
}
public void setName(String str){
name = str ;
}
public void setAge(int a){
age = a ;
}
public String getName(){
return name ;
}
public int getAge(){
return age ;
}
};
public class OODemo09{
public static void main(String args[]){
Person per = new Person() ;
per.setName(“张三”) ;
per.setAge(-30) ;
per.tell() ;
}
};
但是，以上的操作中仍然没有解决年龄是负数的情况。需要在setter方法上加上检测措施，而在getter方法上只是简单的把内容返回即可。
class Person{
private String name ; // 表示姓名
private int age ; // 表示年龄
void tell(){
System.out.println(“姓名：” + getName() + “；年龄：” + getAge()) ;
}
public void setName(String str){
name = str ;
}
public void setAge(int a){
if(a>0&&a<150)
age = a ;
}
public String getName(){
return name ;
}
public int getAge(){
return age ;
}
};
public class OODemo10{
public static void main(String args[]){
Person per = new Person() ;
per.setName(“张三”) ;
per.setAge(-30) ;
per.tell() ;
}
};
提示：
在开发中只要是属性就必须封装，只要是封装的属性就必须通过setter及getter方法设置和取得。
3.4、构造方法（重点）
构造方法是在类中定义的，构造方法的定义格式：方法名称与类名称相同，无返回值类型的声明。
观察对象的产生语法：
类名称 对象名称 = new 类名称() ;  既然有“()”则就表示调用的是一个方法，那么此方法实际上就是构造方法
在使用关键字new实例化对象的时候，就会调用类中的构造方法。
提问：
之前的所有代码中好象并没有给出构造方法，那么是怎么调用的？
所有的Java类中肯定都至少会保存一个构造方法，如果在一个类中没有明确的定义一个构造方法的话，则会自动生成一个无参的什么都不做的构造方法。
class Person{
private String name ; // 表示姓名
private int age ; // 表示年龄
public Person(){ // 构造方法
}
void tell(){
System.out.println(“姓名：” + getName() + “；年龄：” + getAge()) ;
}
public void setName(String str){
name = str ;
}
public void setAge(int a){
if(a>0&&a<150)
age = a ;
}
public String getName(){
return name ;
}
public int getAge(){
return age ;
}
};
既然有了构造方法，实际上构造方法的主要作用是为类中的属性初始化的，所以可以通过构造方法进行属性内容的设置，这样以后就可以不用再分别调用setter方法设置属性内容。
class Person{
private String name ; // 表示姓名
private int age ; // 表示年龄
public Person(String n,int a){ // 构造方法
name = n ;
age = a ;
}
void tell(){
System.out.println(“姓名：” + getName() + “；年龄：” + getAge()) ;
}
public void setName(String str){
name = str ;
}
public void setAge(int a){
if(a>0&&a<150)
age = a ;
}
public String getName(){
return name ;
}
public int getAge(){
return age ;
}
};
以上的类中设置了有两个参数的构造方法，那么执行的时候，可以直接调用此构造。
注意：当类中已经明确的定义了一个构造方法的时候，则无参构造将不会自动生成了
class Person{
private String name ; // 表示姓名
private int age ; // 表示年龄
public Person(String n,int a){ // 构造方法
name = n ;
age = a ;
}
void tell(){
System.out.println(“姓名：” + getName() + “；年龄：” + getAge()) ;
}
public void setName(String str){
name = str ;
}
public void setAge(int a){
if(a>0&&a<150)
age = a ;
}
public String getName(){
return name ;
}
public int getAge(){
return age ;
}
};
public class OODemo12{
public static void main(String args[]){
Person per = null ;
per = new Person(“张三”,30) ;
per.tell() ;
}
};
但是，以上的操作方法中，属性的内容可以直接通过构造进行设置，所以，即使设置了错误的内容，也依然可以为属性赋值，那么此时最好的做法是，在构造方法中同样调用检查的操作。
public Person(String n,int a){ // 构造方法
setName(n) ; // 设置name属性
setAge(a) ; // 设置age属性
}
另外，要提醒的是，如果现在需要明确的表示出一个方法是本类中定义的方法也可以加上this.的形式，例如：
public Person(String n,int a){ // 构造方法
this.setName(n) ; // 设置name属性
this.setAge(a) ; // 设置age属性
}
那么在类中构造方法本身也是可以进行重载的，只要参数的类型或个数不同，那么就可以完成构造方法的重载。
class Person{
private String name ; // 表示姓名
private int age ; // 表示年龄
public Person(){}
public Person(String n){
this.setName(n) ;
}
public Person(String n,int a){ // 构造方法
this.setName(n) ; // 设置name属性
this.setAge(a) ; // 设置age属性
}
void tell(){
System.out.println(“姓名：” + getName() + “；年龄：” + getAge()) ;
}
public void setName(String str){
name = str ;
}
public void setAge(int a){
if(a>0&&a<150)
age = a ;
}
public String getName(){
return name ;
}
public int getAge(){
return age ;
}
};
3.5、匿名对象（重点）
匿名：没有名字的对象，观察以下的操作代码：
Person per = new Person(“张三”,30) ;
以上的代码中per表示对象的名字，而new Person()表示的是堆内存的空间，表示的是具体的内容。
public class OODemo14{
public static void main(String args[]){
new Person(“张三”,30).tell() ;
}
};
此对象只能使用一次，因为没有任何的对象引用，所以将称为垃圾，等待被G•C回收。
只使用一次的对象可以通过匿名对象的方式完成，这一点在以后的开发中将经常使用到。

3.6、类设计题目（重点）
现在要求设计一个表示学生的类，里面有学生的三项成绩：计算机成绩、数学成绩、英语成绩
要求可以求总分、平均分、最高、最低分，并且可以输出一个学生的完整信息。
问：此类该如何设计？
分析：先给出一个问题的解决思路
• 根据需要设计出类
• 根据提示的内容定义类中的属性并指定好相关的类型
• 所有的属性必须封装，封装之后的属性通过setter及getter方法设置和取得
• 根据需要增加其他的方法，但是所有的方法都必须在返回后输出，即：类中永远不要出现System.out语句。
• 如果有需要则可以增加构造方法，通过构造设置属性内容，但是在编写构造的时候强烈建议，一定要保留无参构造方法。这一点在以后的开发中非常重要。

在一般的开发中，在进行类的具体代码编写之前应该先给出类图来，用户可以根据此类图得到一个类的完整结构，并根据图形可以编写出相应的类操作。

类图的定义结构如下：
类名称
属性名称
方法名称
其中类名称就直接写：Student即可
属性名称，要按照一个标准格式编写：修饰符 属性名称 ： 属性类型。
|- private的修饰符使用“-”表示：
|- private String name：-name:String
方法名称，也要按照一个标准的格式编写：修饰符 方法名称（参数名称：参数类型）：返回值类型。
|- public的修饰符使用“+”表示：
|- public void setName(String s)：+setName(s:String):void

3.7、String类（绝对重点）
之前的操作中，可以发现，使用String可以表示出一个字符串，但是使用此类的时候也会发现有一点的问题。
从String命名风格可以发现，String是一个类，但是此类在使用的时候却发现可以不用构造方法而直接赋值，那么这样操作有那些特点呢？
3.7.1、String的两种赋值方式
在使用String的时候有两种赋值方式：
• 一种称为直接赋值
• 通过关键字new调用String的构造方法赋值
public class StringDemo01{
public static void main(String args[]){
String str = “hello” ;
System.out.println(“str = ” + str) ;
}
};
也可以通过查找java的文档，找到String类的构造方法：
public String(String original)
下面通过以上的构造完成操作：
public class StringDemo02{
public static void main(String args[]){
String str = new String(“hello”) ; // 通过关键字new进行实例化的操作
System.out.println(“str = ” + str) ;
}
};
先暂时不考虑区别，可以发现String有两种方式，但是比较起来，第一种代码比较简单。
3.7.2、String的比较
S1.equals(s2):比较两个字符串的值的大小
S1 ==s2 :比较两个字符串地址的大小

//四种情况:当连接字符串在编译期能确定值,那么在执行的时候就直接使用该值的对象
第一种情况:
String s1 = “hello”;
String s2 = “hello”;
String s3 = new Sting (“hello”
S1 == s2;// true;
S1 == s3;// false
第二种情况:
String a = “a1”;
Sring aa = “a”+1;
a == aa; //re;
Int i = 1;
Sring aaa = “a”+i
a == aaa; //false
三情况：
String b = “b1”;
Final int x=1;
String bb =”b”+x;
b ==bb;//true;
第四:
String c = “cc”;
Final String cc = getC ()
String ccc = “ c” + cc;
C = ccc //false;
Public static String getC () {
Return “c”;
}

问题：两个数字如何比较大小？
public class StringDemo03{
public static void main(String args[]){
int x = 30 ;
int y = 30 ;
System.out.println(x==y) ;
}
};
以上操作的返回结果是true，下面继续看String，String本身也可以以上的方式比较。
public class StringDemo04{
public static void main(String args[]){
String str1 = “hello” ; // 声明字符串，内容为hello
String str2 = new String(“hello”) ; // 声明字符串，内容为hello
String str3 = str2 ; // 将str2的空间给str3
System.out.println(“str1 == str2 ” + (str1==str2)) ; // false
System.out.println(“str2 == str3 ” + (str2==str3)) ; // true
System.out.println(“str1 == str3 ” + (str1==str3)) ; // false
}
};
以上的操作结果出现了false，但是这些字符串的内容都是一样的，为什么有真有假呢？下面通过内存关系图来进行分析。

从内存中可以发现，现在程序中比较的并不是字符串的内容，而是字符串所在的内存地址，所以“==”比较的时候比较的是地址的值。
如果要想比较内容的话，该怎么办呢？则需要依靠String中的方法：
public boolean equals(String anObject)
以上的方法返回boolean类型的数据，同时接收字符串数据，将进行字符串是否相等的判断。
public class StringDemo05{
public static void main(String args[]){
String str1 = “hello” ; // 声明字符串，内容为hello
String str2 = new String(“hello”) ; // 声明字符串，内容为hello
String str3 = str2 ; // 将str2的空间给str3
System.out.println(“str1 equals str2 ” + (str1.equals(str2))) ; // true
System.out.println(“str2 equals str3 ” + (str2.equals(str3))) ; // true
System.out.println(“str1 equals str3 ” + (str1.equals(str3))) ; // true
}
};
以上的三个字符串的内容都是一样的，所以在经过equals方法比较之后，所有的结果都是true，表示内容完全相等。
3.7.3、一个字符串就是String的匿名对象
通过一个字符串观察能否调用出equals()方法，如果可以，则表示是一个匿名对象
public class StringDemo06{
public static void main(String args[]){
System.out.println(“hello”.equals(“hello”)) ; // true
}
};
从以上的操作代码中就不难理解直接赋值的操作了。
直接赋值就相当于将在堆中的对象内容给了一个名字而已。所以直接赋值的方式实际上还是引用传递。
3.7.4、两种赋值的区别
之前说过String有两种赋值情况，一种是直接赋值，另外一种是使用关键字new完成，下面分析一下使用那种方式更合适。
String str = new String(“hello”) ;
以上是使用关键字new完成的，那么通过内存分析，来观察这种方式的问题。

通过以上的分析，发现使用new关键字开辟的字符串，会开辟两个空间，其中一个将成为垃圾，使用此种方式明显不好。
如果现在直接使用赋值的方式，肯定会开辟一个，而且还有另外一个明显的好处。
public class StringDemo08{
public static void main(String args[]){
String str1 = “hello” ; // 三个字符串内容完全一样
String str2 = “hello” ;
String str3 = “hello” ;
System.out.println(“str1 == str2 ” + (str1==str2)) ; // false
System.out.println(“str2 == str3 ” + (str2==str3)) ; // true
System.out.println(“str1 == str3 ” + (str1==str3)) ; // false
}
};
以上的三个比较返回的结果都是true，证明三个字符串所在的内存区域是一样的。

如果一个字符串采用了直接赋值的方式，那么以后如果其他字符串对象声明的内容是完全一样的， 则将不会再重新开辟新的内存空间，而是指向已有的内存空间，这种设计在设计模式上讲称为共享设计模式。
可以简单的理解为在Java的低层存在一个共享的字符串池，如果里面发现了内容，则不会再重复声明，如果没有内容，则才会重新声明。
开发中一定要使用直接赋值的方式，new的方式根本不使用。
3.7.5、String的内容不可改变 （任何数据类型碰到String（字符串）都向字符串转型。）
有些同学此时就该迷茫了，为什么不可改变。
public class StringDemo09{
public static void main(String args[]){
String str = “hello” ;
str += “world” ;
str += ” !!!” ;
System.out.println(str) ;
}
};
以上的最终内容是改变了，但是真的改变了吗？观察内存分析图。

实际上来讲，改变的只是内存地址的空间指向，所以在开发中以下的操作代码是不建议编写的：
public class StringDemo10{
public static void main(String args[]){
String str = “hello” ;
for(int x=0;x<1000;x++){
str += x ;
}
System.out.println(str) ;
}
};
因为本程序一是会产生大量的垃圾，二是要不断修改地址的指向，所以性能非常的差，开发中就可以通过修改以上的程序来提升性能。
提示：任何数据类型碰到String（字符串）都向字符串转型。
public class StringDemo11{
public static void main(String args[]){
int i = 10 ;
int j = 20 ;
String str = “10 + 20 = ” ;
System.out.println(str + i + j) ;
System.out.println(str + ( i + j ) ) ;
}
};
3.8、String类的相关操作方法（重点）
String本身是一个类，那么在此类中提供了很多与字符串操作相关的方法，这些常用的方法下面依次来观察一下。
3.8.1、字符与字符串
在其他的语言中基本上都使用字符数组表示字符串，那么在Java中为了支持这些操作，所以方便的提供了一些与字符操作有关的方法。
No. 方法名称 类型 描述
1 public char charAt(int index) 普通 根据下标找到指定的字符
2 public char[] toCharArray() 普通 以字符数组的形式返回全部的字符串内容
3 public String(char[] value) 构造 将全部的字符数组变为字符串
4 public String(char[] value,int offset,int count) 构造 将指定范围的字符数组变为字符串
范例：将字符串变为字符数组
public class StringAPIDemo01{
public static void main(String args[]){
String str = “helloworld” ; // 声明一个字符串
char c[] = str.toCharArray() ; // 将字符串变为字符数组
for(int i=0;i

修饰符的访问权限如下表:

                类内部     package内       子类         其他 

public 允许 允许 允许 允许
protected 允许 允许 允许 不允许
default 允许 允许 不允许 不允许
private 允许 不允许 不允许 不允许

3.13 Java源文件的基本结构
• 源文件的基本语法：
– []
– []
– +
例如：
package school;
import java.util.List;
import java.io.*;
public class Student {
private List Teacher;
public void printSheet(Writer output) { … }
}

package语句
• 打成包后的类的编译和执行：
– 如果在程序Student.java中已定义了包cn.edu.tsinghua.college,编译时采用如下方式：
• javac Student.java
则编译器会在当前目录下生成Student.class文件，如果程序不在cn\edu\tsinghua\college目录下，则必须再在适合位置(destpath目录)手动创建这些子目录，将Test.class复制到该目录下，这样，这个类才可以被使用。
• javac -d destpath Student.java
则编译器会自动在destpath目录下建立子目录cn\edu\tsinghua\college,并将生成的.class文件都放到destpath\ cn\edu\tsinghua\college下。
import语句
• 在需要使用不同的包中的类时，使用import语句来引入所需要的类
• import 语句的语法为：
– import [.].;
– import [.].*;
• 编译器如何寻找import语句中指定的包或者类？
– 在CLASSPATH指定的路径下寻找
– 默认情况下，系统会自动引入java.lang包中的所有类
3.14 常用的包
1. java.lang—-包含一些Java语言的核心类，如String、Math、Integer、System和Thread，提供常用功能。
2. java.awt—-包含了构成抽象窗口工具集（abstract window toolkits）的多个类，这些类被用来构建和管理应用程序的图形用户界面(GUI)。
3. java.applet—-包含applet运行所需的一些类。
4. java.net—-包含执行与网络相关的操作的类。
5. java.io—-包含能提供多种输入/输出功能的类。
6. java.util—-包含一些实用工具类，如定义系统特性、使用与日期日历相关的函数。
3.15 面向对象编程的术语
• 类（class）
• 对象（object）
– 也称：实例（instance)
• 属性（attribute）
– 也称：成员变量、实例变量（instance variable)
• 方法（method）
• 构造器（constructor）
• 包（package)

4、总结
1、 类与对象的关系、定义格式、引用传递
2、 通过private可以实现封装型，被封装的属性无法被外部直接访问，通过setter或getter方法完成
3、 构造方法：一个类中至少存在一个构造方法，如果没有定义构造方法的话，会默认生成一个无参的，什么都不做的构造方法，构造方法在使用关键字new实例化对象的时候被默认调用。
4、 String类的特点、比较、常用方法
5、 引用传递作为重点内容，一定要巩固内存图的分析方法
6、 this关键字，调用属性、方法、构造方法、表示当前对象
7、 对象的比较操作
5、预习任务
1、 static关键字
2、 内部类
3、 对象数组
6、作业
1、 全面复习全部的内容和知识点，本章的所有内容全部是重点，必须完整的掌握。
2、 开发题：
定义并测试一个代表员工的Employee类。它的属性包括“员工姓名”、“员工号码”、“员工基本薪水”、“员工薪水增长额”；他的方法包括“构造方法”、“获取员工姓名”、“获取员工号码”、“获取员工基本薪水”、“计算薪水增长额”及“计算增长后的工资总额”。