关于JAVA面向对象基础整理以及个人的理解(适合初学者阅读)

JAVA的基础语法等都跟C有很大的相似之处，所以这里就不多啰嗦了。直接从数组开始。

数组：

1.声明

int [] a;

在声明的过程中，并没有分配空间给数组。我们可以在声明的同时，用new来分配相应的空间

int [] a = new int[100];

这里开辟了一个空间为100大小的数组，内存分配也完成了。

我们可以在声明的同时也确定元素个数

int [] a = new int[]{1,3,5,7,9};

面向对象(重点)

class Human
{

int height;

void breath()

{

System.out.println("呼呼呼..");

}

}

Human类包含两个成员:一个数据成员height,另一个是方法breath()。

▲数据成员即为属性,方法即为行为。

通过对象来调用方法或者数据成员

Human person = new Human();

person.breath();

通过方法来使用对象的私有变量

class Human
{

private int height;

int getHeight()

{

return height;

}

}

主函数省略没写，如输出结果默认height为0

Human person = new Human();

person.height();

构造方法

特征:1.与类名相同

2.无返回值

class Human

{

int height;

Human(int h)

{

height=h;

}

}

使用构造器

Human person = new Human(160);  //传参

构造方法重载

class Human

{

int height;

Human(int h)

{

height=h;

}

Human(int h,String name)

{

height=h;

System.out.println("我叫"+name);

}

}

JAVA会根据你传入的参数选择构造器进行构造。

当没写构造器的时候，系统默认给你使用空构造器。

封装与接口

Java通过三个关键字来控制对象的成员的外部可见性(visibility): public, private, protected。

• public: 该成员外部可见，即该成员为接口的一部分
• private: 该成员外部不可见，只能用于内部使用，无法从外部访问。

(protected涉及继承的概念，放在以后说)

方法一般置为public作为接口,而重要的数据成员一般置为private。

class Human
{

private int height;

public int getHeight()

{

return height;

}

}

也就是说在外部直接使用height是错误的。必须通过调用getHeight()方法得到其值

Human person = new Human();

System.out.println(person.getHeight());

接口(interface)

以杯子为例，定义一个杯子的接口

interface Cup{

void addWater(int h);

void drinkWater(int h);

}

在interface中，我们

• 不需要定义方法的主体
• 不需要说明方法的可见性(接口默认为public)

我们可以在一个类的定义中实施接口，比如下面的MusicCup (可以播放音乐的杯子):

class MusicCup implements Cup

{

public void addWater(int h)

{

water = water + h;

}

public void drinkWater(int h)

{

water = water - h;

}

private int water = 0;

}

我们使用接口时，必须将接口中的所有方法都要写出，否则将会报错。

当然除了使用接口，我们在类中也可以定义其他方法。例如：

class MusicCup implements Cup

{

public void addWater(int h)

{

water = water + h;

}

public void drinkWater(int h)

{

water = water - h;

}

public int getWater()

{

return water;

}

private int water = 0;

}

实施多个接口

一个类可以实施不止一个的interface。比如我们有下面一个interface:

interface MusicPlayer{

void play();

}

将MusicCup实施两个接口

class MusicCup implements Cup,MusicPlayer

{

public void addWater(int h)

{

water = water + h;

}

public void drinkWater(int h)

{

water = water - h;

}

public void play()

{

System.out.println("lala....la");

}

private int water = 0;

}

类的继承

Human类(基类)

class Human

{

public int getHeight()

{

return height;

}

public void growHeight(int h)

{

height = height + h;

}

public void breath()

{

System.out.println("hu....hu.....hu");

}

private int height;

}

现在我们定义一个女人(Woman)类,使用继承，使用基类的基本特征,避免重复

class Woman extends Human  //此时子类具有父类的所有方法(breath().growHeight().getHeight等等)

{

public Human giveBirth()

{

System.out.println("生宝宝啦");

return (new Human(20));

}

}

加入main方法测试

class Test

{

public static void main(String [] args)

{

Woman aWoman = new Woman();

aWoman.growHeight(120);        //直接调用父类的方法

System.out.println(aWoman.getHeight());

}

}

方法覆盖

class Woman extends Human

{

public Human giveBirth()

{

System.out.println("生宝宝啦");

return (new Human(20));

}

public void breath()

{

super.breath();        //调用父类的breath()方法

System.out.println("su....");

}

}

注意，此时我们位于衍生层，依然可以通过super来调用基类对象的breath()方法。当我们外部调用Woman类时，由于方法覆盖，就无法再调用基类对象的该方法了。

构造方法继承之后

在了解了基类对象和衍生层的概念之后，衍生类的构造方法也比较容易理解。

我们要在衍生类的定义中定义与类同名的构造方法。在该构造方法中:

• 由于在创建衍生对象的时候，基类对象先被创建和初始化，所以，基类的构造方法应该先被调用。我们可以使用super(argument list)的语句，来调用基类的构造方法。
• 基类对象创建之后，开始构建衍生层 (初始化衍生层成员)。这和一般的构建方法相同，参考构造方法与方法重载

class Human

{

public Human(int h)

{

height = h;

}

private int height;

}

class Woman extends Human

{

public Woman(int h)

{

super(h);

System.out.println("我们让父类中的height初始化");

}

}

关于static

类的所有对象共享“人口”数据。这样的数据被称为类数据成员(class field)。

在类定义中，我们利用static关键字，来声明类数据成员，比如:

class Human

{

private static int population;

private static boolean is_mammal = true;

}

我们定义了两个类数据成员: population和is_mammal。所有Human对象都共享一个population数据；任意Human对象的is_mammal(是哺乳动物)的属性都为true。

类数据成员同样要设置访问权限。对于声明为public的类数据成员，可以利用class.field的方式或者object.field(如果存在该类的对象)的方式从外部直接访问。这两种访问方式都是合理的，因为类数据成员可以被认为是类的属性，可以认为是所有成员共享的属性。如果类数据成员被定义为private，那么该类数据成员只能从类的内部访问。

(上面将is_mammal设置成了public，只是为了演示。这样做是挺危险的，万一有人使用 Human.is_mammal=false;，所有人类都遭殃。还是那个基本原则，要尽量将数据设置为private。)

static方法

我们也可以有类方法，也就是声明为static的方法。类方法代表了类可以实现的动作，其中的操作不涉及某个具体对象。如果一个方法声明为static，那么它只能调用static的数据和方法，而不能调用非static的数据和方法。

下面我们增加一个static方法getPopulation()，该方法返回static数据population:

class Human

{

private static int population;

private static boolean is_mammal = true;

public static int getPopulation()

{

return population;                      //类方法只能访问类数据成员

}

}

两种方法调用类方法。类名.方法 或者 对象.方法

class Test

{

public static void main(String [] args)

{

System.out.println(Human.getPopulation());      //直接是 类名.方法

Human person = new Human();

System.out.println(person.getPopulation());      //对象.方法

}

}

final定义

final关键字的基本含义是: 这个数据/方法/类不能被改变了。

• final基本类型的数据: 定值 (constant value)，只能赋值一次，不能再被修改。
• final方法: 该方法不能被覆盖。private的方法默认为final的方法。
• final类: 该类不能被继承。

普通类型的对象也可以有final关键字，它表示对象引用(reference)不能再被修改。即该引用只能指向一个对象。但是，对象的内容可以改变 (类似于C中的static指针)。我们将在以后介绍对象引用。

如果一个基本类型的数据既为final，也是static，那么它是只存储了一份的定值。这非常适合于存储一些常量，比如圆周率。

interface继承

在实施接口中，我们利用interface语法，将interface从类定义中独立出来，构成一个主体。interface为类提供了接口规范。

在继承中，我们为了提高程序的可复用性，引入的继承机制。当时的继承是基于类的。interface接口同样可以继承，以拓展原interface。

接口继承(inheritance)与类继承很类似，就是以被继承的interface为基础，增添新增的接口方法原型。比如，我们以Cup作为原interface:

interface Cup{

void addWater(int w);

void drinkWater(int w);

}

我们在继承Cup的基础上，定义一个新的有刻度的杯子的接口，MetricCup

interface MetricCup extends Cup

{

void getWater();           //返回水量

}

interfacede的多重继承

在Java类的继承中，一个衍生类只能有一个基类。也就是说，一个类不能同时继承多于一个的类。在Java中，interface可以同时继承多于一个interface，这叫做多重继承(multiple inheritance)。

比如我们下面有一个player接口

interface Player{

void play();

}

我们新增一个MusicCup的接口。它既有Cup接口，又有Player接口，并增加一个display()方法原型。

interface MusicCup extends Player,Cup

{

void display();

}

抽象类

在生活中，我们会有一些很抽象的概念。这些抽象的概念往往是许多类的集合，比如:

• 粮食 (可以是玉米、小麦、大米)
• 图形 (可以是三角形、圆形、正方形)

再比如，我们之前举出了例子:

• 人类 (可以是男人、女人)

抽象到具象必须完善抽象类中的方法，否则该类还是抽象类

abstract class Food

{

public abstract void eat();

public void happyFood()

{

System.out.println("好好吃");

}

}

类中的方法可以声明为abstract，比如上面的eat()。这时，我们不需要具体定义方法，只需要提供该方法的原型。这与接口类似。当我们在比如Corn类中继承该类时，需要提供eat()方法的具体定义。

类中的另一个方法happyFood()并不是

当一个类中出现abstract方法时，这个类的声明必须加上abstract关键字，否则Java将报错。一个abstract类不能用于创建对象。

所有内容来自于

作者：Vamei 出处：http://www.cnblogs.com/vamei

笔记整理:Ten10