Java第六章总结

6.1面对对象概述

1.对象

在面向对象中，类和对象是最基本、最重要的组成单元。类实际上是表示一个客观世界某类群体的一些基本特征抽象。对象就是表示一个个具体的东西。所以说类是对象的抽象，对象是类的具体.
 

2.类

类:同一类事物的统称,如果将现实世界中的一个事务抽象成对象,类就是这类对象的统称;类:同一类事物的统称,如果将现实世界中的一个事务抽象成对象,类就是这类对象的统称;

类是构造对象时所依赖的规范 更为恰当的描述是,类是世间事物的抽象称呼,而对象则是这个事物相对应的实体.(类是封装对象的属性和行为的载体).

3.面对对象程序设计的特点

面向对象程序设计具有以下特点:

封装性.

继承性.

多态性.

1.封装:面向对象编程的核心思想.将对象的属性和行为包装起来,其载体就是类,类通常对客户隐藏其实现细节,这就是封装的思想.保证了类内部数据结构的完整性,提高了程序的可维护性.

2.继承:类之间的这种关系被称为关联.关联主要描述两个人类之间的一般二次关系,继承是关联的一种.(继承性主要利用特定对象之间的共有属性)

继承关系可以用树型关系来表示,父类与子类存在一种层次关系.一个类处于继承体系中,它既可以是其他类的父类,为其他类提供属性和行为,也可以是其他类的子类,继承父类的属性和方法,如三角形既是图形类的子类也是等边三角形的父类.

3.多态:将父类应用于子类的特征就是多态.多态的实现并不依赖具体类,而是依赖于抽象类和接口.
 

初始化的默认值如下：
整数型（byte、short、int 和 long）的基本类型变量的默认值为 0。
单精度浮点型（float）的基本类型变量的默认值为 0.0f。
双精度浮点型（double）的基本类型变量的默认值为 0.0d。
字符型（char）的基本类型变量的默认值为 “\u0000”。
布尔型的基本类型变量的默认值为 false。
数组引用类型的变量的默认值为 null。如果创建了数组变量的实例，但没有显式地为每个元素赋值，则数组中的元素初始化值采用数组数据类型对应的默认值。 

 6.2类与对象 

JAVA中定义使用class关键字,其语法如下:

class类名称{undefined
  //类的成员变量
  //类的成员方法
}

1. 成员变量

在JAVA中对象的属性也称为成员变量,成员变量的定义与普通变量的定义一样,语法如下:

数据类型 变量名称 [  = 值 ];(表示可选内容,即定义变量时可以其赋值,也可以不为其赋值.)

 2.成员方法 

声明成员方法可以定义类的行为，行为表示一个对象能够做的事情或者能够从一个对象取得的信息。类的各种功能操作都是用方法来实现的，属性只不过提供了相应的数据。一个完整的方法通常包括方法名称、方法主体、方法参数和方法返回值类型

一个方法还可以没有返回值，即返回类型为 void，像 main() 方法。method_name 表示自定义的方法名称，方法的名称首先要遵循标识符的命名约定

 

 注意:[权限修饰符] 可以时public,private,protected中的任意一个,也可以不写,主要用来控制方法的访问权限;"返回值类型"指定方法返回数据的类型,可以是任何类型,如果方法不需要返回值,则使用关键字void;一个成员方法既可以有参数,也可以没有参数,参数可以是对象也可以是基本数据类型.
 
paramList 表示参数列表，这些变量都要有自己的数据类型，可以是原始数据类型，也可以是复杂数据类型，一个方法主要依靠参数来传递消息。方法主体是方法中执行功能操作的语句。其他各修饰符的含义如下。
public、private、protected：表示成员方法的访问权限。
static：表示限定该成员方法为静态方法。
final：表示限定该成员方法不能被重写或重载。
abstract：表示限定该成员方法为抽象方法。抽象方法不提供具体的实现，并且所属类型必须为抽象类。

3.构造方法 

 class Book(
   public Book()  {  //构造方法 
}
}

方法的形参和实参具有以下特点：
形参变量只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。因此，形参只有在方法内部有效，方法调用结束返回主调方法后则不能再使用该形参变量。
实参可以是常量、变量、表达式、方法等，无论实参是何种类型的量，在进行方法调用时，它们都必须具有确定的值，以便把这些值传送给形参。因此应预先用赋值、输入等办法使实参获得确定值。
实参和形参在数量、类型和顺序上应严格一致，否则会发生“类型不匹配” 的错误。
方法调用中发生的数据传送是单向的，即只能把实参的值传送绐形参，而不能把形参的值反向地传送给实参。因此在方法调用过程中，形参的值发生改变，而实参中的值不会变化。

 

 

 

4. 局部变量

局部变量:在成员方法内定义一个变量

在方法被执行时创建,在方法执行结束时被销毁.在使用时必须进行赋值操作或被初始化

public String getName() { //定义一个getName()方法
int id =0;  //局部变量
setName ("Jave"); //调用类中其他方法
return id+this.name;  //设置方法返回值
}

// 访问类变量
System.out.println(Person.eyeNum);
// 访问实例变量
Person p = new Person();
System.out.println(p.name);
// 为实例变量赋值
p.name = "孙悟空";
// 为类变量赋值
Person.eyeNum = 2;
System.out.println(p.name+ "," + Person.eyeNum);
Person p2 = new Person();
// 类变量不会随着实例变量变化
System.out.println(p2.eyeNum);

5 .局部变量的有效范围

{
    int a =1;
}
// 无法得到a变量
System.out.println(a);

可以将局部变量的有效范围称为变量的作用域,局部变量的有效范围从该变量的声明开始到变量的结束为止.在互不嵌套的作用域中可以同时声明两个名称和类型相同的局部变量.但 是在相互嵌套的区域中不可以这样声明,如果将局部变量id在方法体的for循环中再次定义,编译就i会报错.

6. 对象的创建

对象可以认为是在一类事物中抽象出某一个特例.语法如下:

Test test = new Test();
Test test = new Test("a");

1. 使用 new 关键字创建对象

类名 对象名 = new 类名()；

2. 调用 java.lang.Class 或者 java.lang.reflect.Constuctor 类的 newlnstance() 实例方法

java.lang.Class Class 类对象名称 = java.lang.Class.forName(要实例化的类全称);
类名 对象名 = (类名)Class类对象名称.newInstance();

3. 调用对象的 clone() 方法 

类名对象名 = (类名)已创建好的类对象名.clone();
 

 

7.访问对象的属性和行为

在 Java 中，要引用对象的属性和行为，需要使用点（.）操作符来访问。对象名在圆点左边，而成员变量或成员方法的名称在圆点的右边。

1. 对象名.属性(成员变量) // 访问对象的属性

2. 对象名.成员方法名() // 访问对象的方法

Student stu =new Student)):// 创建 Student 类的对象 stu 
stu.Name ="李子文";// 调用stu对象的Name属性并赋值
stu.Sex = true: //调用stu对象的Sex属性并赋值 
stu.Age = 15: // 调用stu对象的Age属性并赋值 

 Student stu = nul1 stu.Name = "李子文"; stu.Sex = true; stu.Age = 15;

就会出现异常结果Exception in thread "main" java.lang.NullPointerException

此异常是开发中最常见的异常，也会始终伴随着每位开发人员，使用了未实例化的对象则肯定会出现此异常。 

8. 对象的销毁

(1)对象引用超过其作用范围,这个对象将被视为垃圾;

例: { Example e = new example();} [对象e超过其作用范围,将消亡]

(2)将对象赋值为null;

例:{Example e = new Example();

e=null;}(当对象被置为null值时,将消亡)
 

 在 Java 的 Object 类中还提供了一个 protected 类型的 finalize() 方法，因此任何 Java 类都可以覆盖这个方法，在这个方法中进行释放对象所占有的相关资源的操作。 

在 Java 虚拟机的堆区，每个对象都可能处于以下三种状态之一。
 
1）可触及状态：当一个对象被创建后，只要程序中还有引用变量引用它，那么它就始终处于可触及状态。
 
2）可复活状态：当程序不再有任何引用变量引用该对象时，该对象就进入可复活状态。在这个状态下，垃圾回收器会准备释放它所占用的内存，在释放之前，会调用它及其他处于可复活状态的对象的 finalize() 方法，这些 finalize() 方法有可能使该对象重新转到可触及状态。
 
3）不可触及状态：当 Java 虚拟机执行完所有可复活对象的 finalize() 方法后，如果这些方法都没有使该对象转到可触及状态，垃圾回收器才会真正回收它占用的内存。

9.this关键字

 this 关键字是 Java 常用的关键字，可用于任何实例方法内指向当前对象，也可指向对其调用当前方法的对象，或者在需要当前类型对象引用时使用。

this.属性名
大部分时候，普通方法访问其他方法、成员变量时无须使用 this 前缀，但如果方法里有个局部变量和成员变量同名，但程序又需要在该方法里访问这个被覆盖的成员变量，则必须使用 this 前缀。

提示：当一个类的属性（成员变量）名与访问该属性的方法参数名相同时，则需要使用 this 关键字来访问类中的属性，以区分类的属性和方法中的参数。 

this.方法名
this 关键字最大的作用就是让类中一个方法，访问该类里的另一个方法或实例变量。

this( )访问构造方法
this( ) 用来访问本类的构造方法（构造方法是类的一种特殊方法，方法名称和类名相同，没有返回值。详细了解可参考《Java构造方法》一节），括号中可以有参数，如果有参数就是调用指定的有参构造方法。

6.3static关键字

 1静态变量

类的成员变量可以分为以下两种：

静态变量（或称为类变量），指被 static 修饰的成员变量。

实例变量，指没有被 static 修饰的成员变量。 

静态变量与实例变量的区别如下：
 
1）静态变量
运行时，Java 虚拟机只为静态变量分配一次内存，在加载类的过程中完成静态变量的内存分配。
在类的内部，可以在任何方法内直接访问静态变量。
在其他类中，可以通过类名访问该类中的静态变量。
 
2）实例变量
每创建一个实例，Java 虚拟机就会为实例变量分配一次内存。
在类的内部，可以在非静态方法中直接访问实例变量。
在本类的静态方法或其他类中则需要通过类的实例对象进行访问。

2 .静态常量

用final static 修饰一个成员变量,这个成员变量就会变成一个静态常量.

例: final static double PI = 3.1415926;(给静态常量命名时所有的字母都应该大写)

3 .静态方法

如果想要使用类中的成员方法,需要将先这个类进行实例化,但有些时候不想或者无法创建类的对象时,还要调用类中的方法才能够完成业务逻辑,此时就可以使用静态方法.

类名.静态方法();

静态方法与实例方法的区别如下：
静态方法不需要通过它所属的类的任何实例就可以被调用，因此在静态方法中不能使用 this 关键字，也不能直接访问所属类的实例变量和实例方法，但是可以直接访问所属类的静态变量和静态方法。另外，和 this 关键字一样，super 关键字也与类的特定实例相关，所以在静态方法中也不能使用 super 关键字。
在实例方法中可以直接访问所属类的静态变量、静态方法、实例变量和实例方法。

4 .静态代码块
用static修饰代码区域可以称之为静态代码块.语法如下:

Public static void main(String[] args) {
//方法体
}

静态代码块指 Java 类中的 static{ } 代码块，主要用于初始化类，为类的静态变量赋初始值，提升程序性能。

静态代码块的特点如下：

静态代码块类似于一个方法，但它不可以存在于任何方法体中。
静态代码块可以置于类中的任何地方，类中可以有多个静态初始化块。 
Java 虚拟机在加载类时执行静态代码块，所以很多时候会将一些只需要进行一次的初始化操作都放在 static 代码块中进行。
如果类中包含多个静态代码块，则 Java 虚拟机将按它们在类中出现的顺序依次执行它们，每个静态代码块只会被执行一次。
静态代码块与静态方法一样，不能直接访问类的实例变量和实例方法，而需要通过类的实例对象来访问。

6.4类的主方法 

在 Java 中，main() 方法是 Java 应用程序的入口方法，程序在运行的时候，第一个执行的方法就是 main() 方法。main() 方法和其他的方法有很大的不同。

Public static void main(String[] args) {
//方法体
}

其中，使用 main() 方法时应该注意如下几点：

访问控制权限是公有的（public）。
main() 方法是静态的。如果要在 main() 方法中调用本类中的其他方法，则该方法也必须是静态的，否则需要先创建本类的实例对象，然后再通过对象调用成员方法。
main() 方法没有返回值，只能使用 void。
main() 方法具有一个字符串数组参数，用来接收执行 Java 程序的命令行参数。命令行参数作为字符串，按照顺序依次对应字符串数组中的元素。
字符串中数组的名字（代码中的 args）可以任意设置，但是根据习惯，这个字符串数组的名字一般和 Java 规范范例中 main() 参数名保持一致，命名为 args，而方法中的其他内容都是固定不变的。
main() 方法定义必须是“public static void main(String[] 字符串数组参数名)”。
一个类只能有一个 main() 方法，这是一个常用于对类进行单元测试（对软件中的最小可测试单元进行检查和验证）的技巧。

public class Student {
public void Speakl() {
System.out.println("你好!");}
public static void Speak2() {
System.out.println("Java!");}
public static void main(String[] args) {
//Speak1():// 错误调用
Speak2(); // 可以直接调用静态方法Speak2() Student t = new Student():
t.Speak1():// 调用非静态方法，需要通过类的对象来调用
}

 由上面代码可以看出，在 main() 方法中只能直接调用静态方法，如果想调用非静态方法，需要将当前类实例化，然后通过类的对象来调用。 

public class TestMain {
public static void main(String[] args) {
int n =args.length; // 获取参数数量 System.out.println("一共有 "+n+"个参数"); if(n > 0) {
// 判断参数个数是否大于0 for(int i = 0;i <n;i++) {
System.out.println(args[i]);
}
}}

 6.5小结

对 Java 语言来说，一切皆是对象。把现实世界中的对象抽象地体现在编程世界中，一个对象代表了某个具体的操作。一个个对象最终组成了完整的程序设计，这些对象可以是独立存在的，也可以是从别的对象继承过来的。对象之间通过相互作用传递信息，实现程序开发。