Java笔记--面向对象

****************************************************************************************************************** 类和对象

1.类名：一个或多个有意义的单词连缀而成，每个单词首字母大写，其它字母全部小写，单词与单词之间不要使用任何的分隔符。

 

2.对于一个类定义而言，可以包含三种最常见的成员：构造器、成员变量和方法

 

3.方法名/成员变量名：第一个单词首字母小写，后面每个单词首字母大写，其它字母全部小写，单词与单词之间不使用任何分隔符。

 

4.创建对象的根本途径是构造器，通过关键字new来调用某个类的构造器即可创建这个类的实例，如下

//使用Person类定义一个Person类型的变量

Person p;

//通过关键字new调用Person类的构造器，返回一个Person实例

p = new Person();

 

5.对象的this引用

this关键字总是指向调用该方法的对象

static修饰的方法不能使用this引用，如果确实需要在静态方法中访问另一个普通方法，则只能重新创建一个对象，用创建的对象来调用想要调用的普通方法

普通方法访问类中的其它方法、成员变量时无须使用this前缀，但是如果方法里面有个局部变量和成员变量同名，但是程序又需要在该方法中访问这个被覆盖的成员变量，则必须使用this前缀。

 

****************************************************************************************

方法

1.Java语言中，方法不能独立存在，方法必须属于类或对象

2.执行方法时必须使用类或对象来作为调用者，即所有方法都必须使用“类.方法”或“对象.方法”的形式来调用

 

3.static修饰的方法属于这个类本身，既可以使用类作为调用者来调用，也可以使用对象作为调用者来调用，因为使用static修饰的方法还是属于这个类的，因此使用该类的任何对象来调用这个方法时将会得到相同的执行效果。

没有static修饰的方法只能使用对象作为调用者来调用，不能使用类来调用。

 

4.形参个数可变的方法（P121）

Java允许定义形参个数可变的参数，从而允许为方法指定数目不确定的形参，如果在定义方法时，在最后一个形参的类型后增加三点（...）,则表明该形参可以接受多个参数值，多个参数值被当做数组传入。

形参个数可变的参数本质就是一个数组参数，即使是采用形参个数可变的形式来定义方法，调用该方法时也一样可以为形参可变的参数传入一个数组。

个数可变的形参只能处于形参列表的最后，一个方法中最多只能包含一个个数可变的形参。

 

5.方法重载

形参的个数、类型、顺序其一不同即可作为方法重载的条件，但仅仅返回值不同不能作为方法重载的条件。

 

****************************************************************************************

成员变量和局部变量

1. 实例变量（不以static修饰）

成员变量

类变量（以static修饰）

所有变量

形参

局部变量 方法局部变量（在方法中定义）

代码块局部变量（在代码块中定义）

 

2.成员变量无须显式初始化，只要为一个类定义了类变量或实例变量，系统就会在这个类的准备阶段或创建该类的实例的时候进行默认初始化

 

3.与成员变量不同的是，局部变量除了形参之外，都必须显式的进行初始化，也就是说，必须先给方法局部变量和代码段局部变量指定初始值，否则不可访问它们。

 

4.Java允许局部变量和成员变量同名，如果方法里的局部变量和成员变量同名，局部变量就会覆盖成员变量，如果需要 在这个方法里引用被覆盖的成员变量，则可以使用this（对于实例变量）或类名（对于类变量）作为调用者来限定访问成员变量。

 

5.当程序需要访问类成员时，尽量使用类作为主调，而不是使用对象作为主调，这样可以避免程序产生歧义，提高程序的可读性。

 

6.定义局部变量时，系统并未为这个变量分配内存空间，直到程序为这个变量赋初值时，系统才会为局部变量分配内存，并将初始值保存在这块内存中。局部变量不属于任何类或实例，它只是保存在其方法所在的栈内存中。如果局部变量是一个引用类型的变量，则这个变量里存放的是地址，通过该地址引用到该变量实际引用的对象或数组。

 

7.变量的使用规则

（1）如果需要定义的变量是用来描述某个类或某个对象的固有信息的，如人的身高、体重，这种变量应该定义成成员变量。如果这种信息对这个类的所有实例完全相同，或者说是类相关的，比如人的眼睛的数目都为2个，这种类相关的信息应该定义成类变量；如果这种信息是实例相关的，例如人的身高、体重等，每个人实例的身高、体重可能互不相同，这种信心是与实例相关的，所以应该定义成实例变量。

（2）用于保存某个类或某个实例状态信息的变量通常应该使用成员变量。

 

****************************************************************************************

隐藏和封装

1.面向对象的三大特征：封装、继承、多态

2.封装：隐藏对象的属性和实现细节，仅对外提供公共访问方式

3.良好的封装需要从两个方面考虑

（1）把对象的成员变量和实现细节隐藏起来，不允许外部直接进行访问（高内聚）

（2）把方法暴露出来，让方法来控制对这些成员变量进行安全的访问和操作。（低耦合）

以上都需要通过访问控制符来实现。

 

4.访问控制符：private、default、protected、public

default：包访问权限，如果类里的一个成员（包括成员变量、方法和构造器）或者一个外部类不使用任何访问控制符修饰，就称它是包访问权限的，default访问控制的成员或外部类可以被相同包下的其他类访问。default并没有对应的访问控制符，当不使用任何访问控制符来修饰类或类成员时，系统默认使用该访问控制级别。

 

5.包（欠缺）

 

 

6.构造器

默认构造函数的权限和所属类一致

 

当程序员调用构造器时，系统会先为该对象分配内存空间，并为这个对象执行默认初始化，这个对象已经产生了，这些操作在构造器执行之前就已经完成了，也就是说，当系统开始执行构造器的执行体之前，系统已经创建了一个对象，只是这个对象还不能被外部程序访问，只能在该构造器中通过this来引用。

 

在同一个类中，可以通过this关键字来用一个构造器来调用另一个重载的构造器

public class Apple

{

private String color;

private String name;

private int weight;

Apple(String color,String name)

{

this.color = color;

this.name = name;

}

 

Apple(String color,String name,int weight)

{

this(color,name);

this.weight = weight;

}

}

****************************************************************************************************************** 内部类

1.定义：将一个类定义在另一个类中，对里面那个类就称为内部类（内置类、嵌套类）

 

2.内部类的访问规则

（1）内部类中可以直接访问到外部类中的成员，包括 私有成员

（2）外部类中要访问内部类，必须建立内部类对象

（3）当内部类在外部类的成员位置上时，可以被private修饰

（4）之所以内部类可以直接访问外部类中的成员，是因为内部类中持有了一个外部类的引用（一般被隐式调用），格式：

外部类名.this.

 

class Outer

{

int x = 3;

 

class Inner //内部类

{

int x = 4;

void function()

{

//内部类中可以直接访问到外部类中的成员，包括 私有成员

//如果该内部类中没有定义int x = 4;则下面的语句可以直接访问

//到外部类中的数据成员x

//System.out.println("x:" + x);

 

//之所以内部类可以访问外部类中的成员，是因为内部类中持有

//一个外部类的引用，格式：外部类名.this

System.out.println("x:" + Outer.this.x);

}

}

 

void method()

{

//外部类中要访问内部类，必须建立内部类对象

Inner in = new Inner();

in.function();

}

}

 

class OuterDemo

{

public static void main(String[] args)

{

Outer o = new Outer();

o.method();

}

}

 

3.访问格式（不做重点掌握，开发时一般不写）

(1）当内部类定义在外部类的成员位置上，而且非私有，则可以在外部其它类中直接建立内部类对象。

格式：外部类名.内部类名 变量名 = 外部类对象.内部类对象

Outer.Inner in = new Outer().new Inner();

 

(2)当内部类在外部类的成员位置上时，就可以被成员修饰符所修饰，比如

private ：将内部类在外部类进行封装

static : 内部就有了静态的特性

当内部类被static修饰后，只能访问外部类中的static成员，出现了访问局限，因此静态内部类并不常见

 

补充：在外部其它类中，如何访问静态外部类那？

（1）访问静态内部类中的非静态成员

 

//function()是内部类的非静态方法

//function（）是非静态方法，所以需要创建内部类对象调用

//注意Outer是外部类的类名

new Outer.Inner().function();

（2）访问静态内部类的静态成员4

new Outer.Inner.function();

注意：在内部类中定义了静态成员，则该内部类必须是静态的

在外部类中的静态方法访问内部类时，内部类也必须是 static修饰的