Java面向对象总结

面向对象

对象和类的概念

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

 类是用于描述同一类型的对象的一个抽象概念，类中定义了这一类对象所因具有的静态和动态属性。  类可以看成一类对象的模板，对象可以看成该类的一个具体实例。

对象的两要素

 属性

 用于描述对象静态特性（结构特性）的一个数据项。如描述一个人可用姓名、年龄、身份证号等属性。

 方法

 用于描述对象动态特性（行为特性）的一个操作系列。如每个人都具有工作、学习等行为特性。











格式：引用类名 对象名=new 构造函数名（参数）； 例：class DuiXiang{} 则建立对象为：DuiXiang mingZi=new DuiXiang（）； 如果要实现功能，则格式为： mingZi.变量或函数名（）；

面向对象编程特征

 封装

 继承

 多态

封装

 封装是允许有选择地隐藏类中的属性和方法

继 承

 继承（重用）现有类生成新类

继承关系

 父类(超类)是有其他类继承其行为的类

 继承其他类的类称为子类

多态概念

 多态是具有表现多种形态的能力的特征

 多态与继承并不是孤立的，他们之间存在着紧密的联系，多态是建立在继承的基础之上的  不同的子类继承自同一个父类，父类的同一个方法以不同的方式实现

Java与面向对象

 对象是Java程序的核心，在Java程序中“万事万物皆对象”。

 对象可以看成是静态属性(成员变量)和动态属性(方法)的封装体。

 类是用来创建同一类型的对象的“模板”，在一个类中定义了该类对象所应具有的成员变量以及方法。  J2SDK提供了很多类供编程人员使用，编程人员也可以定义自己的类。

成员变量

 成员变量可以使Java语言中任何一种数据类型(包括基本类型和引用类型)．

 在定义成员变量时可以对其初始化，如果不对其初始化，Java使用默认值对其初始化．  成员变量的作用范围为整个类体．

Java面向对象基本概念 ---引用

 Java语言中除基本类型之外的变量类型都称之为引用类型。

 Java中的对象是通过引用对其操作的。例如：

//声明了一个String类型的引用变量，但并没有使它指向一个对象

String s;

//使用new语句创建一个String类型的对象并用s指向它以后可以通过s完成对其的操作。 s = new String(“Hello world”);

 如何在内存中区分类和对象？

 类是静态的概念，代码区

 对象是new出来的，位于堆内存，类的每个成员变量在不同的对象中都有不同的值（除了静

态变量）而方法只有一份，执行的时候才占用内存

对象的创建和使用

 必须使用new关键字创建对象

 使用 对象.成员变量 来引用对象的成员变量

 使用 对象.方法(参数列表)来调用对象的方法

 同一类的每个对象有不同的成员变量存储空间

 同一类的每个对象共享该类的方法

构造方法

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

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

 构造方法与类同名且没有返回值.

构造函数

创建对象时，使用构造函数初始化对象的成员变量。

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

约定俗成的命名规则

 类名的首字母大写

 变量名和方法名首字母xiao写

 运用标识

方法的重载

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

表选择对应的方法。

构造方法的重载

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

this关键字

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

 当前使用方法的对象是this。

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

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

 使用格式：

 this.成员变量名；

 this.成员方法名

 this();

static 关键字

 三种修饰：修饰类的变量、方法和构造代码块。静态方法只能直接引用和访问静态变量和方法

 声明为static的方法称为静态方法或类方法。静态方法可以直接调用静态方法，访问静态变量，但是

不能直接访问实例变量和实例方法。静态方法中不能使用this关键字，因为静态方法不属于任何一个实例。静态方法不能被子类的静态方法覆盖。

 特有属性随着对象存储于堆内存中，而static修饰后的属性，存在于方法区.

 可以通过对象引用或类名(不需要事例化)访问静态成员。 什么时候使用静态修饰符？ 当对象中出现共享数据时，使用静态修饰。 但对象内的特有数据要定义成非静态存在于堆内存中。 而对于方法时： 当功能内部没有访问到非静态数据时，（即对象的特有数据） 那么可以使用静态修饰。 静态代码块： 用于给类做初始化的。不管有没有对象都执行，只要调用了类里面成员或方法，就会执行，而且优先

于主函数，优先执行级别最高。

 例： class JingTai {static int age; static String name; static//静态代码块初始化类的，所以最先运行。 { System.out.println("name="+name); } //下面是构造代码块，第二个运行 { System.out.println("age="+age); } public static void jing(int x)//被对象调用，第三个运行。 { x =age+1;//因为age是静态的，所以能调用 System.out.println("x="+x); }} class FaDa { public static void main(String[] args) { JingTai p =new JingTai(); p.jing(2); } }

package 和 import语句

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

类的多重类命名空间。

 package语句作为Java源文件的第一条语句，指明该文件中定义的类所在的包（若缺省该语句，则指

定为无名包）。

 它的格式为：

 package pkg1[.pkg2.[pkg3…]];

 Java编译器把包对应于文件系统的目录管理，package语句中，用„ . ‟来指明包（目录）的层次，例如

使用语句

 package com.sxt;

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

 如果将一个类打包，则使用该类时，必须使用该类的全名（com.sxt.MyClass），Java编译器才会在找

到该类。

 也可以使用import在文件的开头引入要使用的类：

import com.sxt.MyClass;

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

……

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

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

package import 总结

 如果想将一个类放入包中，在这个类源文件第一句话写package

 必须保证该类的class文件位于正确目录下

 该类的源码可能会产生影响

 删除或转移到另外的目录

 另外的类想访问的话

 写全名

 引入

 *

 具体类名

 访问位于同一个包中的类不需要引入

 必须class文件的最上层包的父目录为与classpath下。

文档注释：

 文档注释有编译工具进行，具体一个要注意的地方是：类名前必须要有public修饰。要编译的方法名

必须有public 修饰

 javadoc注释标签语法

@author 对类的说明标明开发该类模块的作者

@version 对类的说明标明该类模块的版本

@see 对类、属性、方法的说明 参考转向，也就是相关主题

@param 对方法的说明对方法中某参数的说明

@return 对方法的说明 对方法返回值的说明

@exception 对方法的说明 对方法可能抛出的异常进行说明

J2SDK中主要的包介绍

 Java.lang---包含一些Java语言的核心类，如String、Math、Integer、System和Thread，提供常用功能。  Java.awt---包含了构成抽象窗口工具集(abstract window toolkits)的多个类，这些类被用来构建和管理应

用程序的图形用户界面．

 Java.net---包含执行与网络相关的操作的类．

 Java.io---包含能提供多种输入／输出功能的类．

 Java.util---包含一些实用工具类，如定义系统特性，使用与日期日历相关的函数．

类的继承与权限控制

 继承就是将两个类的共性描述提取出来，单独进行描述，从而简化代码，提高复用性。

 格式：class 子类名 extends 父类名

 关健字为extends ：继承

 判断两个类是否有所属关系，那么我们就继承一下，看父类所具有的内容属性，子类是否全都需要

具备。如果是，那么他们所属关系成立，就是继承。

 注意：千万不要为了获取其他类的功能，简化代码而继承。

 必须是类与类之间有所属关系才可以继承。

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

 <modifier>class<name>[extends <superclass>]{…}

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

 Java语言中：java只支持单继承，不支持多继承。

 java支持多层继承。也就是一个继承体系

访问控制

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

问权限。

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

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

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

方法的重写

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

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

 重写方法不能使用比被重写方法更严格的访问权限。

 注意：

 重载：只看同名函数的参数列表。

 重写：子父类方法要一模一样。



super 关键字

在Java类中使用super来引用基类的成分

• 表示当前活动对象的直接父类对象。

• 使用格式：

• super.成员变量名；

• super.成员方法名；

• super（[参数]）

• 注意：静态方法中不能使用this和super。

Object 类

 Object类是所有Java类的根基类

 如果在类的声明中未使用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 类名 来判断该引用类型变量所”指向”的对象是否属于该类或该类的

子类.

 子类的对象可以当作基类的对象来使用称作向上转型,反之称作向下转型

动态绑定和多态

 动态绑定是指“在执行期间(而非编译期)”判断所引用对象的实际类型，根据其实际的类型调用其相应

的方法。

 上面例子中，根据Lady对象的成员变量pet所引用的不同的实际类型而调用相应的enjoy方法。 抽象类

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

象方法。

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

 抽象类不能被实例化。

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

final关键字

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

 final的成员变量

 final的局部变量(形参)

 final的方法不能被重写

 final的类不能被继承

接口

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

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

的实现。

接口的特性

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

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

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

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

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

 接口可以被类多实现，也是对多继承不支持的转换形式。java支持多实现。

 1，类可以实现多个接口，用关健字：implements 如：

 class Test implements JieKou,JieKou2

 2，类继承后，仍可以实现多个接口，如：

 class Test extends Demo implements JieKou,JieKou2

 3，接口在可以实现多继承,如：

 interface Test extends A,B

 例：

abstract class Student

{

abstract void study();学生都要学习，所以可以作为父类来给子类继承。}

interface Smoking

{

void smoke();//抽烟不是所有学生都会，所以，不可以继承，不然所有学生都抽烟了，所以定义为接口，让需要的类实现就行。

}

class ZhangSan extends Student implements Smoking

//继承后再实现，这样就实现了功能的扩展。

{

void study(){}

public void smoke(){}//记得要复写,因为父类是抽象的。

}

class Lisi extends Student

{

void study()

{

System.out.prtintln("study") }

多态：

1，多态的体现

对象多态性分为两种：一种属于方法的重载与覆写，另外一种对象多态性

对象多态性，从概念上非常好理解，在类中有子类和父类之分，所以对象多态性就从此而来： · 向上转型：将子类实例变为父类实例

|- 格式：父类 父类对象 = 子类实例 ；  自动完成

|- 以基本数据类型操作为例：int i = 'c' ;  因为 c的容量比 int 小，所以可以自动完成 · 向下转型：将父类实例变为子类实例

|- 格式：子类 子类对象 = （子类）父类实例 ；  强制完成

|- 以基本数据类型操作为例：char c = (char)98 ;  因为整型的容量比 char 大，所以强制完成 2，多态的前提

 必须是类与类之间有关系。要么继承，要么实现。

 通常还有一个前提：存在覆盖。

3，多态的好处

 多态的出现大大的提高程序的扩展性。

4，多态的弊端：

 提高了扩展性，但是只能使用父类的引用访问父类中的成员。

 如何要访问子类特有对象必须强制转换为子类对象。

Java免费学习资料直播公开课群：175161984