Java总结之面向对象

【面向对象的设计思想】

面向对象的基本思想是，从现实世界中客观存在的事务出发来构造软件系统，并在系统的构造中尽可能运用人的自

然思维方式。

面向对象更加强调运用人类在日常的思维逻辑中经常采用的思想方法与原则，如抽象、分类、继承、聚合、多态等

。

【对象和类的概念】

对象：用计算机语言堆问题域中事物的描述，对象通过“属性(attribute)”和“方法(method)”来分别对应事物所

具有的静态属性和动态属性。

类是用于描述同一类型的对象的一个抽象的概念，类中定义了这一类对象所应具有的静态和动态属性。

类可以看成一类对象的模板，对象可以看成该类的一个具体实例。

类和对象之间的关系：关联关系；继承关系；聚合关系（整体和部分）；实现关系；多态。

【为什么用对象？】

面向对象的编程——一组对象互相配合通过沟通完成特定功能

所有的paradigm都是对现实问题的抽象（对象是对现实问题的抽象）

对象都是对外服务的接口

通过继承可以复用

对象隐藏内部服务的实现

通过聚合可以服用

面向对象更加容易使我们达到这些年来苦苦追求的境界

Reusable、Extensibility、维护和替换更加方便、……

组建——比对象更高层次上的抽象（二进制级别）

EJB、Web Service、CORBA、COM、……

【构造方法（构造函数）】

使用 new+构造方法 创建一个新对象。

构造函数是定义在Java类中的一个用来初始化对象的函数。

构造函数与类同名且没有返回值。

例如：Person类的构造函数：

public class Person {
int id;
int age;
Person(int n,int i) {
id = n;
age = i;
}
}

当没有指定构造函数时，编译器为类自动添加形如"类名() {}"的构造函数。

构造方法前面没有返回值。

【约定书城的命名规则】

类名的首字母大写；变量名和方法名的首字母大写；采用驼峰标识。

【对内存与栈内存的概念】

......

【方法的重载】

方法的重载是指一个类中可以定义有相同的名字，但参数不同的多个方法。调用时，会根据不同的参数表选择对应的

方法。

例如：在Person类中添加如下方法：

void info() {
System.out.println("My id is "+id);
}
void info(String t) {
System.out.println(t+" "+id+" "+age);
}

与普通方法一样，构造方法也可以重载。

【this关键字】

在类的方法定义中使用的this关键字代表使用该方法的对象的引用。

党必须支出当前使用方法的对象是谁时要使用this。

有时使用this可以处理方法中成员变量和参数重名的情况。

this可以看做是一个变量，它的值是当前对象的引用

【static关键字】

在类中，用static声明的成员变量为静态成员变量，它为该类的公用变量，在第一次使用时被初始化，对于该类的所

有对象来说，static成员变量只有一份。

用static声明的方法为静态方法，在调用该方法时，不会将对象的引用传递给它，所以在static方法中不可访问

非static的成员。

静态方法不再是针对某个对象调用，所以不能访问非静态成员。

可以通过对象引用或类名（不需要实例化）访问静态成员。

静态变量的使用： 类名.静态变量 ； 静态变量不属于某个变量而属于类。

【package和import语句】

为便于管理大型软件系统中数目众多的类，解决类的命名冲突问题，Java引入包(package)机制，提供类的多重类命名

空间。

package语句格式：package pkg1[.pkg2[.pkg3...]];

Java编译器把包对应于文件系统的目录管理，package语句中，用'.'来指明包(目录)的层次，例如使用语句

package com.lasolmi;

则该文件中所有的类位于.\com\lasolmi 目录下

如果将一个类打包，则使用该类时，必须使用该类的全名(例如:com.lasolmi.MyClass),Java编译器才会找到该类。

也可以使用import在文件的开头引入要使用到的类；例如：

import com.lasolmi.Myclass;

import java.util.*;//引入java.util包中所有的类

... ... ...

MyClass myClass = new MyClass();//可以直接使用类名

... ... ...

可以不需要用import语句直接使用java.lang包中的类.

必须class文件的最上层包的父目录位于classpath下。

【J2SDK中主要的包介绍】

java.lang:包含一些Java语言的核心类，如String、Math、Integer、System和Thread，提供常用功能。

java.awt:包含了构成抽象窗口工具集(abstract window toolkits)的多个类，这些类被用来构建和管理应用程序的图

形用户界面(GUI)。

java.applet:包含applet运行所属的一些类。

java.net:包含执行与网络相关的操作的类。

java.io:包含提供多种输入/输出功能的类。

java.util:包含一些实用工具集，如定义系统特性、使用与日期日历相关的函数。

【访问控制】

Java权限修饰符public protected private置于类的成员定义前，用来限定其他对象对该类对象成员的访问权限。

|--------------------------------------------------------|
|  修饰符  |  类内部  |  同一个包  |  子类  |  任何地方  |
|----------|----------|------------|--------|------------|
| private  |   Yes    |            |        |            |
|----------|----------|------------|--------|------------|
| default  |   Yes    |    Yes     |        |            |
|----------|----------|------------|--------|------------|
|protected |   Yes    |    Yes     |  Yes   |            |
|----------|----------|------------|--------|------------|
|  public  |   Yes    |    Yes     |  Yes   |    Yes     |
|--------------------------------------------------------|

对于class的权限修饰只可以用public和default。

public类可以在任意地方被访问

default类只可以被同一个包内部的类访问

【类的继承与权限控制】

Java中使用extends关键字实现类的继承机制，其语法规则为：

<modifier> class <name> [extends <quperclass>] {......}

通过继承，子类自动拥有了基类(superclass)的所有成员(成员变量和方法).

Java只支持单继承，不允许多继承：一个子类只能有一个基类；一个基类可以派生出多个子类

【方法的重写】

在子类中可以根据需要对从基类中继承来的方法进行重写。

重写方法必须和被重写方法具有相同方法名称、参数列表和返回类型。

重写方法不能使用比重写方法更严重的访问机制。

【super关键字】

在Java类中使用super来引用基类的成分；例如：

class FatherClass {
public int value;
public void f() {
value = 100;
System.out.println("FatherClass.value="+value);
}
}
class ChildClass extends FatherClass {
public int value;
public void f() {
super.f();
value = 200;
System.out.println("ChildClass.value="+value);
System.out.println(value);
System.out.println(super.value);
}
}

【继承中的构造方法】

子类的构造的过程中必须调用其基类的构造方法。

子类可以在自己的构造方法中使用super(argument_list)调用基类的构造方法。

使用this(argument_list)调用本类的另外的构造方法

如果子类的构造方法中没有显式地调用基类构造方法，则系统默认调用基类无参数的构造方法。

如果子类构造方法中既没有显式调用基类构造方法，而基类中又没有无参的构造方法，则编译出错。

【Object类】

Object类是所有Java类的根基类

如果在类的生命中未使用extends关键字知名其基类，则默认基类为Object类

public class Person {

...

}

等价于：

public class Person extends Object {

...

}

【toString方法】

Object类中定义有public String toString()方法，其返回值是String 类型，描述当前对象的有关信息。

在进行String与其他类型数据的连接操作时(如：System.out.println("info"+person)),将自动调用该对象类

的toString()方法

可以更具需要在用户自定义类型中重写toString()方法。

【equals方法】

Object类中定义有：

public boolean equals(Object obj)方法

提供低你对象是否“相等”的逻辑。

Object的equals方法定义为：x.equals(y)当x和y是同一个对象的应用时返回true否则返回false

J2SDK提供的一些类，如String，Date等，重写了Object的equals方法，调用这些类的equals方法，x.equals(y),当x

和y所引用的对象是同一类对象且属性内容相等时(并不一定是相同对象)，返回true否则返回false。

可以根据需要在用户自定义类型中重写equals方法。

【对象转型(casting)】

一个基类的引用类型变量可以“指向”其子类的对象。

一个基类的引用不可以访问其子类对象新增加的成员(属性和方法)。

可以使用引用变量instanceof类名来判断该引用型变量所“指向”的对象是否属于该类或该类的子类。

子类的对象可以当做基类的对象来使用乘坐向上转型（upcasting）,反之称为向下转型（downcasting）.

范例：

class Animal {...}

class Dog extends Animal {...}

main() ...

Animal a = new Animal();

a = new Dog();

...

【动态绑定和多态】

动态绑定是指在执行期间（而非编译器）判断所引用对象的实际类型，根据其实际的类型调用其相应的方法。

【抽象类】

用abstract关键字来修饰一个类时，这个类叫做抽象类；用abstract来修饰一个方法时，该方法叫做抽象方法。

含有抽象方法的类必须被声明为抽象类，抽象类必须被继承，抽象方法必须被重写。

抽象类不能被实例化。

抽象方法只需声明，而不需实现。

【Final关键字】

final的变量的值不能够被改变

final的成员变量

final的局部变量(形参)

final的方法不能够被重写

final的类不能够被继承

(final相当于C++里面的const)

【接口】

接口(interface)是抽象方法和常量值的定义的集合。

从本质上讲，接口是一种特殊的抽象类，这种抽象类中只包含常量和方法的定义，而没有变量和方法的实现。

接口定义举例：

public interface Runner {

public static final int id = 1; // == int id = 1;"public static finnal"写或不写是一样的

public void start();

public void run();

public void stop();

}

多个无关的类可以实现同一个接口。

一个类可以实现多个无关的接口。

与继承关系类似，接口与实现类之间存在多态性。

定义Java类的语法格式：

<modifier> class <name> [extends <superclass>][implements <interface> [,<interface>]* ]

{<declarations>*}

接口里面不用谢abstract，因为所有的方法都是abstract的。

【接口特性】

接口可以多充实先；

接口中声明的属性默认为public static final的；也只能是public static final的；

接口只能定义抽象方法，而且这些方法默认为public的、也只能是public的；

接口可以继承其他的接口，并添加新的属性和抽象方法。

接口举例：

interface Singer {
public void sing();
public void sleep();
}
class Student implements Singer {
private String name;
Student(String name) {
this.name = name;
}
public void study() {
System.out.println("studying");
}
public String getName() {return name;}
public void sing() {
System.out.println("student is singing");
}
public void sleep() {
System.out.println("studet is sleeping");
}
}

【总结】

对象和类的概念

类(对象)之间的关系

面向对象设计思想

class

new

引用的概念

构造方法的概念

方法重载

构造方法重载

this

static

package & import

private default protected public

extends

overwrite

final

Object

toString

equals

upcasting downcasting

polymophysm / dynamic binding / late

abstract class

interface

implements