java 对象的三大特性_Java面向对象的三大特性

Java面向对象的三大特性

Java面向对象的三大特性分别为：封装、继承、多态，下面我们一起来详细了解一下!

1.封装：

说得通俗一点，就是把细节隐藏起来，把该公开的公开，把该私有的私有。

那如何封装一个类?

类中含属性和方法， 属性可有可无，并且应该设置为private.

方法可有可无，对外的方法的应该公开，对内的方法应该私有.

一个类的方法，大致有：

构造方法 -> 可以生成

存/取 属性值的方法，也就是 getter/setter 属性方法. -> 可以生成

业务方法，实现此类对象的真正业务功能，是程序员真正需要花心思考虑的。

针对类中的方法，有以下两种封装策略:

1).把存/取属性方法、构造方法、业务方法全部封装到同个类中。

2).把业务方法单独独立出来，形成一个业务类，这个类用来操作与它所相关的实体对象。它一般由接口与实现类组成.

实体(Entity)对象，就是指含业务属性和属性存/取 方法的对象.

如：封装策略一:

public class Account {

private long id;

private String name;

private double balance;

private String pwd;

....

// getter/setter方法

// 构造方法

....

// 业务方法

public void withdraw(double money) {

if(balance < money) {

System.out.println("余额不足");

return ;

}

balance -= money;

}

public void deposit(double money) { }

}

//采用封装策略二：

首先是实体类

public class Account {

private long id;

private String name;

private double balance;

private String pwd;

....

// getter/setter方法

// 构造方法

}

//再定义一个业务类，操作Account

public class AccountService {

// 业务方法

public void withdraw(Account a,double money) {

if(a.getBalance() < money) {

System.out.println("余额不足");

return ;

}

a.setBalance(a.getBalance - money);

}

public void deposit(Account a, double money) { }

}

注：此处在真实的场景中应该由接口与实现类组成。

2.继承

关键字： extends

类继承的语法：

public class 子类名 extends 父类名 {

//属性定义

//方法定义

}

注：一个类A继承了另一个类B，那么类A中就继承(得到)了类B中所有的非私有成员.

继承的特点：

1).传递性,如果A继承B，C又继承A, 那么C也继承B。

2).JAVA是单继承的。

JAVA中有一个顶级父类，就是java.lang.Object 类如果一个类没有继承任何父类，那么它将会自动继承于Object类.

单继承的特点，可以保证JAVA的整个类层次结构一颗“倒置树”状结构

如：

//父类

public class Super {

private String name;

//

//..

}

// 子类

public class Sub extends Super {

//...

}

继承所产生的几个概念:

父类,也叫超类，或叫 基类。

子类，也叫派生类。

何时使用继承?

当两个类之间具备“ IS A "的关系时，才应该采用继承关系. 否则，不要滥用继承.

如：

Apple IS A Fruiut

Cat is a Animal

...

继承是一种代码复用技术，但是提出这个“IS A”的参考要求是为了更好地“限制”继承，因为，代码复用技术除了继承外，还有其它的设计思想，比如 组合/聚合设计思想.

-- ----------------------------------------------------------

对象创建的过程：

a).分配空间

b).赋初始值

c).调用构造方法

如果有了父类，则应该是：

第一步：递归地按以上三步创建 父类对象.

## ############################################

创建子类对象时，一定会递归地创建父类对象

## ############################################

super关键字：

作用：

a).在构造方法中使用，调用父类构造方法,必需放在第一条语句

b).当子类的属性与父类属性同名时，并且父类的属性不是private的这种情况下，在子类中，存在2个同名的属性，那么子类的属性会掩盖(shadow)掉父类的同名属性，这时，可以通过super.属性名来区别。

-- -------------------------------------------------------

有了继承关系，父类类型的引用可以指向任意的子类对象。

编译时类型

就是指变量在编译时的类型，也就是申明变量时它的类型

运行时类型

就是指代码运行时变量的`真正类型，也就是new操作符后面所跟的对象类型.

如：

Animal c2;

c2 = new Cat(); //可以指向 Cat的实例

Object c3 = new Cat(); //Object类型的引用可以指向任意对象。

c3.catchMouse(); // error, 此处不能调用此方法。

所以，Object类型可以成为任意对象的编译时类型.

但是，编译时类型只能看到编译时类型所拥有的成员.[这就是为什么c3.catchMouse() 会报错，因为c3的编译时类型是Object，并没有catchMouse()方法]

-- ------------------------------------------------------

共性与个性

共性尽可能写在父类之中，这样所有子类都可以共享.

个性尽可能写在子类之中，每种子类都具备不同的个性.

-- ------------------------------------------------------

instanceof 操作符

作用：用来判断一个对象是否属于某个类型

语法：

变量名 instanceof 类型

以上表达式返回的是 boolean类型.

当instanceof后面的类型是变量的运行时类型或可以是做为它编译时类型的类型时，返回true.

如：

Animal a = new Dog();

if(a instanceof Dog) { //成立

...

}

if(a instanceof Animal){ //成立

...

}

if(a instanceof Cat){ //不成立

...

}

3.多态.

具备同一种编译时类型的对象引用，调用同一个方法,而在运行时具备不同的形为. 这就是多态.

多态的条件

1).要有继承关系

2).要有方法重写(override)

方法的组成部份：

修饰符 返回类型 方法名([参数列表]) 抛出异常 { }

方法重写的条件

a).修饰符要一样，或者子类方法的修饰符要比父类宽

b).返回类型一致，或者子类方法的返回类型是父类方法返回类型的子类。

c).方法名一样

d).参数列表要一模一样。

e).抛出的异常只能比父类要小。

-- ------------------------------------------------------

多态的应用

面向父类编程,这是一种编程思想，具体在代码上可以有如下三种体现：

a).对象的编译时类型尽可能地写 父类类型

如：Animal c = new Cat();

b).方法的参数尽可能写父类

试想，如果要写义一个功能，这个功能尽可以用小猫做参数，也可以用小狗做参数，则：

public void m(Cat c) { c.eat(); }

public void m(Dog c) { c.eat(); }

即然Cat类和Dog类有共同的父类，为什么不考虑如下的方式：

public void m(Animal a) { a.eat(); } //显然，此方法更好，可以有效地减少方法的重载。

c).方法返回类型尽可能地写 父类.

如：

public Animal createAnimal() { .... } //这样的好处是这个方法有更多的可选择性，也就是并不只是返回一种类型。

增强for循环,只能用循环迭代数组和集合. 它是JDK5.0后才有的.

语法：

for(类型 变量名 : 数组或集合对象) {

//代码

}

注:类型 指的是数组元素的类型或集合元素的类型.

-- -----------------------------------------------------

toString方法

打印一个对象时，会自动调用该对象的 toString方法。因为toString()方法是 Object类中的方法，所以，每个对象都有toString()方法。但是,Object的toString方法的默认实现只是返回对象的”内存地址“，所以，如果你想要输出你自己定义的对象字符串格式，请 重写 toString方法.

-- --------------------------------------------------------

练习：

设计一个形状类Shape, 没有任何的属性。

含如下方法：

public double area() { return 0.0;}

public double girth() { return 0.0; }

再写一个子类：圆形(Circle) 继承于 形状类.自行设计属性，并重写父类的 area和girth方法.

静态[static]与常量[final]

静态域与静态方法,关键字：static

1.static用来修饰属性(成员变量)

static修饰的属性叫静态属性，也称为 类变量.

语法：

访问控制修饰符 static 变量类型 变量名 [=初始值];

我们知道，普通属性是对象所拥有的，而类变量(静态属性)则是类所拥有的，是所有对象所共享的。

2.static用来修饰方法(成员方法)

就是在方法的修饰符中加入 static关键字，这个方法就成为了静态方法。

静态方法的特点：

a).静态方法无需创建对象来调用。直接通过类名.方法名 来调用.

b).静态方法中不能直接访问非静态成员，只能创建对象来访问非静态成员

c).在静态方法中不能使用this关键字.

-- 再次回顾对象创建的过程

-- 以下三步，都是在类加载时被调用，并且只会被执行一次.

a).分配静态属性的空间

b).给静态属性赋初始值

c).如果静态代码块的话，则调用静态代码块.

-- 以下四步，都是在创建对象时被调用，并且每创建一个对象就执行一次

c).分配非静态属性的空间

d).给非静态属性赋初始值

e).如果有代码块的话，先调用代码块

f).调用构造方法

3.static 用来修饰代码块.

注：静态代码块在类加载时只被执行一次。它的这个特性，我们可以利用静态代码做一些特殊的事情

a).加载本地/远程的大文件到内存中。

b).获取数据库连接池

总之一句话，就是需要费时费力，而且需要长驻内存的资源，这种情况，可以考虑采用静态代码块来负页加载。

【Java面向对象的三大特性】相关文章：