java面向对象的应用

什么是类：

1.具有相同特性（数据元素）和行为（功能）的对象的抽象就是类。因此，对象的抽象是类，类的具体化就是对象，也可以说类的实例是对象，类实际上就是一种数据类型。

2.类具有属性，它是对象的状态的抽象，用数据结构来描述类的属性。

3.类具有操作，它是对象的行为的抽象，用操作名和实现该操作的方法来描述。

 类的语法格式：

1.语法格式：访问修饰符 数据类型 = 初值

2.编写类的属性（考虑修饰符、属性类型、属性名、初始化值）　　

3.编写类的方法（考虑修饰符、返回值类型、方法名、形参等）

***修饰符private:该属性只能由该类的方法访问
***修饰符public:该属性可以被该类以外的方法访问
***类型：任何基本类型，如int、boolean或任何类

 成员变量：1、在方法体外，类体内声明的变量称为成员变量。2、实例变量（不以static修饰）3、类变量（以static修饰）

　　　区别：1、成员变量定义在类中，在整个类中都可以被访问。2、成员变量分为类成员变量和实例成员变量，实例变量存在于对象所在的堆内存中。3、成员变量有默认初始化值。4、成员变量的权限修饰符可以根据需要，选择任意一个

 局部变量：1、在方法体内部声明的变量称为局部变量。2、形参（方法签名中定义的变量）。3、代码块局部变量（在代码块内定义）。

　　区别：1、局部变量只定义在局部范围内，如：方法内，代码块内等。2、局部变量存在于栈内存中。3、作用的范围结束，变量空间会自动释放。4、局部变量没有默认初始化值，每次必须显式初始化。5、局部变量声明时不指定权限修饰符

 方法：1、类中操作的实现过程叫做方法，方法是类或对象行为特征的抽象，也称为函数，一个方法有方法名、返回值、参数、方法体。

　　　2、Java里的方法不能独立存在，所有的方法必须定义在类里。

3、语法格式：

访问修饰符 返回值类型 方法名 (参数列表) {
　　　　　　方法体语句；
　　　　　　return 返回值；
}

4、a、修饰符：方法作用的范围，public, private, protected等。

b、返回值类型：方法要返回的结果的数据类型，return语句传递返回值。
c　返回值：方法在执行完毕后返还给调用它的程序的数据。
d、没有返回值：void。
e、参数：在方法被调用时用于接收外部传入的数据的变量。

构造器：1.它具有与类相同的名称。2.它不声明返回值类型。（与声明为void不同）3.不能被static、final、synchronized、abstract、native修饰，不能有return语句返回值

　　语法格式
　　修饰符 类名 (参数列表) {
　　　　初始化语句；
}

 *********注意部分*******

1.根据参数不同，构造器可以分为如下两类：隐式无参构造器（系统默认提供）显式定义一个或多个构造器（无参、有参）

2.Java语言中，每个类都至少有一个构造器

3.默认构造器的修饰符与所属类的修饰符一致

4.一旦显式定义了构造器，则系统不再提供默认构造器

5.一个类可以创建多个重载的构造器

6.父类的构造器不可被子类继承

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

重     载：

1.在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。

2.与返回值类型无关，只看参数列表，且参数列表必须不同。(参数个数或参数类型)。调用时，根据方法参数列表的不同来区别。

 

重       写：

1.若子类中的方法与父类中的某一方法具有相同的方法名、返回类型和参数表，则新方法将覆盖原有的方法。　

2.发生方法重写的两个方法返回值、方法名、参数列表必须完全一致(子类重写父类的方法)

3.子类方法的访问级别不能低于父类相应方法的访问级别(子类访问级别不能低于父类访问级别)

 

 类的创建并使用：

类中操作的实现过程叫做方法，一个方法有方法名、返回值、参数、方法体。

1.使用new + 构造器创建一个新的对象

2.使用“对象名.对象成员”的方式访问对象成员（包括属性和方法）

3.如果创建了一个类的多个对象，对于类中定义的属性，每个对象都拥有各自的一套副本，且互不干扰。

4.当一个对象被创建时，会对其中各种类型的成员变量自动进行初始化赋值。

封   装：

Java中通过将数据声明为私有的(private)，再提供公共的（public）方法:getXxx()和setXxx()实现对该属性的操作，就叫做封装

　　封装的有点：

　　找到变化并且把它封装起来，你就可以在不影响其它部分的情况下修改或扩展被封装的变化部分，这是所有设计模式的基础，就是封装变化，因此封装的作用，就解决了程序的可扩展性。

　　1.隐藏一个类中不需要对外提供的实现细节；

　　2.使用者只能通过事先定制好的方法来访问数据，可以方便地加入控制逻辑，限制对属性的不合理操作；

　　3.便于修改，增强代码的可维护性；

 　　如何封装：

　　1.私有化属性，即把类中属性的访问修饰符设置为private类型

　　2.提供公共的接口，即给被私有化的属性提供公共的get(),set()方法，来给得到属性和设置值

　　

访问修饰符：

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

2.对于class的权限修饰只可以用public和default(缺省)。

 

this是什么：

1.它在方法内部使用，即这个方法所属对象的引用

2.它在构造器内部使用，表示该构造器正在初始化的对象

3.this表示当前对象，可以调用类的属性、方法和构造器

4.当在方法内需要用到调用该方法的对象时，就用this。

怎样使用this：

1.使用this，调用属性、方法

2.使用this调用本类的构造器

***注意事项：***

1.当形参与成员变量重名时，如果在方法内部需要使用成员变量，必须添加this来表明该变量时类成员

2.在任意方法内，如果使用当前类的成员变量或成员方法可以在其前面添加this，增强程序的阅读性

3.this可以作为一个类中，构造器相互调用的特殊格式

4.使用this()必须放在构造器的首行！

5.使用this调用本类中其他的构造器，保证至少有一个构造器是不用this的。

 JavaBean:

1.什么是JavaBean？
　　JavaBean是一种Java语言写成的可重用组件。

2.所谓javaBean，是指符合如下标准的Java类：
　　a.类是公共的
　　b.有一个无参的公共的构造器
　　c.有属性，且有对应的get、set方法

3.用户可以使用JavaBean将功能、处理、值、数据库访问和其他任何可以用java代码创造的对象进行打包，并且其他的开发者可以通过内部的JSP页面、Servlet、其他JavaBean、applet程序或者应用来使用这些对象。用户可以认为JavaBean提供了一种随时随地的复制和粘贴的功能，而不用关心任何改变。

什么是软件包？

1.包帮助管理大型软件系统：将语义近似的类组织到包中；解决类命名冲突的问题。

2.包可以包含类和子包。

3.例：某航运软件系统包括：一组域对象、GUI和reports子系统

 package:

1.package语句作为Java源文件的第一条语句，指明该文件中定义的类所在的包。(若缺省该语句，则指定为无名包)。

　　格式：package 顶层包名.子包名 ;

2.包对应于文件系统的目录，package语句中，用 “.” 来指明包(目录)的层次；

3.包通常用小写单词，类名首字母通常大写。

import:

1.为使用定义在不同包中的Java类，需用import语句来引入指定包层次下所需要的类或全部类(.*)
　　import语句告诉编译器到哪里去寻找类。

　　格式：import 包名[.子包名…]. <类名 |*>

 ****注意****

1.若引入的包为：java.lang，则编译器默认可获取此包下的类，不需要再显示声明。

2.import语句出现在package语句之后、类定义之前

3.一个源文件中可包含多个import语句

4.可以使用import lee.* ;语句，表明导入lee包下的所有类。而lee包下sub子包内的类则不会被导入。import lee.sub.*;

5.import语句不是必需的，可坚持在类里使用其它类的全名

6.JDK 1.5加入import static语句

JKD中主要的包介绍：

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

2.java.net----包含执行与网络相关的操作的类和接口。

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

4.java.util----包含一些实用工具类，如定义系统特性、接口的集合框架类、使用与日期日历相关的函数。

5.java.text----包含了一些java格式化相关的类

6.java.sql----包含了java进行JDBC数据库编程的相关类/接口

7.java.awt----包含了构成抽象窗口工集（abstract window toolkits）的多个类，这些类被用来构建和管理应用程序的图形用户界面(GUI)。

8.java.applet----包含applet运行所需的一些类。

 继       承：

什么是继承：

　　　　一个类继承另一个类的特征和行为，使得继承类具有被继承类的各种属性和方法。或继承类从被继承类继承方法，使得继承类具有被继承类相同的行为。

　　　　继承的类叫做子类，被继承的类叫做父类

 为什么需要继承：

　　　　多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。

　　　　此处的多个类称为子类，单独的这个类称为父类（基类或超类）。可以理解为:“子类 is a 父类”

继承的作用：

　　　　1.子类继承了父类，就继承了父类的方法和属性。

　　　　2.在子类中，可以使用父类中定义的方法和属性，也可以创建新的数据和方法。

　　　　3.在Java 中，继承的关键字用的是“extends”，即子类不是父类的子集，而是对父类的“扩展”。

 继承的规则：

　　1.子类不能直接访问父类中私有的(private)的成员变量和方法。

　　2.Java只支持单继承，不允许多重继承，即一个子类只能有一个父类

　　3.一个父类可以派生出多个子类

如何使用继承：

1、　　语法格式：
　　class Subclass extends Superclass{ }
　　　　使用extends关键字

2、　　编写父类

　　

3、　　编写子类

　　

super用什么用：

1.super可用于访问父类中定义的属性

2.super可用于调用父类中定义的成员方法

3.super可用于在子类构造方法中调用父类的构造器

 super的使用规则：

1.当子父类出现同名成员时，可以用super进行区分

2.super的追溯不仅限于直接父类

3.super和this的用法相像，this代表本类对象的引用，super代表父类的内存空间的标识

super(参数) 调用父类的构造方法
super.xxx 调用父类的属性或方法

 　　　　　　

如何调用父类的构造器：

1.子类中所有的构造器默认都会访问父类中空参数的构造器

2.当父类中没有空参数的构造器时，子类的构造器必须通过this(参数列表)或者super(参数列表)语句指定调用本类或者父类中相应的构造器，且必须放在构造器的第一行

3.如果子类构造器中既未显式调用父类或本类的构造器，且父类中又没有无参的构造器，则编译出错

什 么 是 多 态：

1.所谓多态就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定，即一个引用变量倒底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。

2.因为在程序运行时才确定具体的类，这样，不用修改源程序代码，就可以让引用变量绑定到各种不同的类实现上，从而导致该引用调用的具体方法随之改变，即不修改程序代码就可以改变程序运行时所绑定的具体代码，让程序可以选择多个运行状态，这就是多态性。

为什么要使用多态？

1.封装、继承、多态。从一定角度来看，封装和继承几乎都是为多态而准备的。这是我们最后一个概念，也是最重要的知识点。

2.消除类型之间的耦合关系。

3.实现多态的技术称为：动态绑定（dynamic binding），是指在执行期间判断所引用对象的实际类型，根据其实际的类型调用其相应的方法。

4.现实中，关于多态的例子不胜枚举。比方说按下 F1 键这个动作，如果当前在 Flash 界面下弹出的就是 AS 3 的帮助文档；如果当前在 Word 下弹出的就是 Word 帮助；在 Windows 下弹出的就是 Windows 帮助和支持。同一个事件发生在不同的对象上会产生不同的结果。

 多 态 的  好 处：

1.可替换性（substitutability）。

多态对已存在代码具有可替换性。例如，多态对圆Circle类工作，对其他任何圆形几何体，如圆环，也同样工作。

2.可扩充性（extensibility）。

多态对代码具有可扩充性。增加新的子类不影响已存在类的多态性、继承性，以及其他特性的运行和操作。实际上新加子类更容易获得多态功能。例如，在实现了圆锥、半圆锥以及半球体的多态基础上，很容易增添球体类的多态性。

3.接口性（interface-ability）。

多态是超类通过方法签名，向子类提供了一个共同接口，由子类来完善或者覆盖它而实现的。如图8.3 所示。图中超类Shape规定了两个实现多态的接口方法，computeArea()以及computeVolume()。子类，如Circle和Sphere为了实现多态，完善或者覆盖这两个接口方法。

4.灵活性（flexibility）。

它在应用中体现了灵活多样的操作，提高了使用效率。

5.简化性（simplicity）。

多态简化对应用软件的代码编写和修改过程，尤其在处理大量对象的运算和操作时，这个特点尤为突出和重要。

 实现多态的条件：

1.继承

 

在多态中必须存在有继承关系的子类和父类。

 

2.重写

 

子类对父类中某些方法进行重新定义，在调用这些方法时就会调用子类的方法。

 

3.向上转型

 

在多态中需要将子类的引用赋给父类对象，只有这样该引用才能够具备技能调用父类的方法和子类的方法。

 

两种形式：

　　1.使用父类作为方法形参实现多态

　　2.使用父类作为方法返回值实现多态

 

类型转换：

基本数据类型的转换：

 

1.自动类型转换：小的数据类型可以自动转换成大的数据类型
　　如long g=20; double d=12.0f

 

 

 

2.强制类型转换：可以把大的数据类型强制转换(casting)成小的数据类型
　　如 float f=(float)12.0;
　　int a=(int)1200L

 

对象的转换：

1.从子类到父类的类型转换可以自动进行（向上转型）

2.从父类到子类的类型转换必须通过造型(强制类型转换)实现（向下转型）

3.无继承关系的引用类型间的转换是非法的

4.在造型前可以使用instanceof操作符测试一个对象的类型

 instanceof运算符：

1、　　 语法：
　　　　x instanceof A：检验x是否为类A的对象，返回值
　　　　为boolean型。

2、　　要求x所属的类与类A必须是子类和父类的关系，否则编译错误。

3、     如果x属于类A的子类B，x instanceof A值也为true。

　　　　

static的作用：

1.为某特定数据类型或对象分配单一的存储空间，而与创建对象的个数无关。

2.实现某个方法或属性与类而不是对象关联在一起

3.被static修饰的成员变量和成员方法独立于该类的任何对象。也就是说，它不依赖类特定的实例，被类的所有实例共享。

4.static对象可以在它的任何对象创建之前访问，无需引用任何对象。

 static成员变量：

1.Java类提供了两种类型的变量：用static关键字修饰的静态变量和不用static关键字修饰的实例变量。

2.静态变量属于类，在内存中只有一个复制，只要静态变量所在的类被加载，这个静态变量就会被分配空间，因此就可以被使用了。

3.对静态变量的引用有两种方式，分别是“类.静态变量"和”对象.静态变量"

4.实例变量属于对象，只有对象被创建后，实例变量才会被分配内存空间，才能被使用，它在内存中存在多个复制，只有用“对象.实例变量”的方式来引用。

static成员方法：

Java中提供了static方法和非static方法。static方法是类的方法，不需要创建对象就可以被调用，而非static方法是对象的方法，只有对象被创建出来后才可以被使用

 使用限制：

1.它们仅能调用其他的static 方法。

2.它们只能访问static数据。

3.它们不能以任何方式引用this 或super。

单例模式：

1.static一个很重要的用途就是实现单例设计模式。

2.单利模式的特点是该类只能有一个实例，为了实现这一功能，必须隐藏类的构造函数，即把构造函数声明为private，并提供一个创建对象的方法

3.由于构造对象被声明为private，外界无法直接创建这个类型的对象，只能通过该类提供的方法来获取类的对象，要达到这样的目的只能把创建对象的方法声明为static

 static代码块：

1.static代码块也叫静态代码块，是在类中独立于类成员的static语句块，可以有多个，位置可以随便放，它不在任何的方法体内

2.JVM加载类时会执行这些静态的代码块，如果static代码块有多个，JVM将按照它们在类中出现的先后顺序依次执行它们

3.static代码块在类中是独立于成员变量和成员函数的代码块的。这些static代码块只会被执行一次

　　　　

final类：

final概念：

Java关键字final有“这是无法改变的”或者“终态的”含义，它可以修饰非抽象类、非抽象类成员方法和变量。

1.final类不能被继承，没有子类，final类中的方法默认是final的。

2.final方法不能被子类的方法覆盖，但可以被继承。

3.final成员变量表示常量，只能被赋值一次，赋值后值不再改变。

4.final不能用于修饰构造方法。

5.父类的private成员方法是不能被子类方法覆盖的，因此private类型的方法默认是final类型的。

 类：

1.final类不能被继承，因此final类的成员方法没有机会被覆盖，默认都是final的。

2.在设计类时候，如果这个类不需要有子类，类的实现细节不允许改变，并且确信这个类不会载被扩展，那么就设计为final类。

 final方法：

1.如果一个类不允许其子类覆盖某个方法，则可以把这个方法声明为final方法。

2.把方法锁定，防止任何继承类修改它的意义和实现。

3.高效。编译器在遇到调用final方法时候会转入内嵌机制，大大提高执行效率。

　　　　　　

抽象（abstract）：

概念：

1.如果一个类没有足够的信息来描述一个具体的对象，而需要其他具体的类来支撑它，那么这样的类我们称它为抽象类。

2.抽象类体现了数据抽象的思想，是实现多态的一种机制。它定义了一组抽象的方法，至于这组抽象方法的具体表现形式有派生类来实现

3.抽象类提供了继承的概念，它的出发点就是为了继承，否则它没有存在的任何意义。所以说定义的抽象类一定是用来继承的，同时在一个以抽象类为节点的继承关系等级链中，叶子节点一定是具体的实现类。

注意：

1.抽象类不能被实例化，实例化的工作应该交由它的子类来完成，它只需要有一个引用即可。

2.抽象方法必须由子类来进行重写。

3.只要包含一个抽象方法的抽象类，该方法必须要定义成抽象类，不管是否还包含有其他方法。

4.抽象类中可以包含具体的方法，当然也可以不包含抽象方法。

5.子类中的抽象方法不能与父类的抽象方法同名。

6.abstract不能与final并列修饰同一个类。

7.abstract 不能与private、static、final或native并列修饰同一个方法。

 　　

接口（interface）

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

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

特点：

1.用interface来定义。

2.接口中的所有成员变量都默认是由public static final修饰的。

3.接口中的所有方法都默认是由public abstract修饰的。

4.接口没有构造器。

5.接口采用多继承机制。

接口的优点：

1.通过接口可以实现不相关类的相同行为，而不需要考虑这些类之间的层次关系。

2.通过接口可以指明多个类需要实现的方法，一般用于定义对象的扩张功能。

3.通过接口可以指明多个类需要实现的方法，一般用于定义对象的扩张功能。

 注意事项：

1.个Interface的方所有法访问权限自动被声明为public。确切的说只能为public，当然你可以显示的声明为protected、private，但是编译会出错！

2.接口中可以定义“成员变量”，或者说是不可变的常量，因为接口中的“成员变量”会自动变为为public static final。可以通过类命名直接访问：ImplementClass.name。

3.接口中不存在实现的方法。

4.实现接口的非抽象类必须要实现该接口的所有方法。抽象类可以不用实现。

5.不能使用new操作符实例化一个接口，但可以声明一个接口变量，该变量必须引用（refer to)一个实现该接口的类的对象。可以使用 instanceof 检查一个对象是否实现了某个特定的接口。例如：if(anObject instanceof Comparable){}。

6.在实现多接口的时候一定要避免方法名的重复。

内存区域：

寄存器：

JVM内部虚拟寄存器，存取速度非常快，程序不可控制。

栈：

保存局部变量的值，包括：a.用来保存基本数据类型的值；b.保存类的实例，即堆区对象的引用(指针)。也可以用来保存加载方法时的帧。

堆：

用来存放动态产生的数据，比如new出来的对象。注意创建出来的对象只包含属于各自的成员变量，并不包括成员方法。因为同一个类的对象拥有各自的成员变量，存储在各自的堆中，但是他们共享该类的方法，并不是每创建一个对象就把成员方法复制一次。

常量池：

JVM为每个已加载的类型维护一个常量池，常量池就是这个类型用到的常量的一个有序集合。包括直接常量(基本类型，String)和对其他类型、方法、字段的符号引用(1)。池中的数据和数组一样通过索引访问。由于常量池包含了一个类型所有的对其他类型、方法、字段的符号引用，所以常量池在Java的动态链接中起了核心作用。常量池存在于堆中。

代码段：

用来存放从硬盘上读取的源程序代码。

数据段：

用来存放static定义的静态成员，一直占用内存。

 *****注意*****

1.一个Java文件，只要有main入口方法，我们就认为这是一个Java程序，可以单独编译运行。

2.无论是普通类型的变量还是引用类型的变量(俗称实例)，都可以作为局部变量，他们都可以出现在栈中。只不过普通类型的变量在栈中直接保存它所对应的值，而引 用类型的变量保存的是一个指向堆区的指针，通过这个指针，就可以找到这个实例在堆区对应的对象。因此，普通类型变量只在栈区占用一块内存，而引用类型变量 要在栈区和堆区各占一块内存。

3..栈中的数据和堆中的数据销毁并不是同步的。方法一旦结束，栈中的局部变量立即销毁，但是堆中对象不一定销毁。因为可能有其他变量也指向了这个对象，直到栈中没有变量指向堆中的对象时，它才销毁，而且还不是马上销毁，要等垃圾回收扫描时才可以被销毁。

4.每一个应用程序都对应唯一的一个JVM实例，每一个JVM实例都有自己的内存区域，互不影响。并且这些内存区域是所有线程共享的。这里提到的栈和堆都是整体上的概念，这些堆栈还可以细分。以上的栈、堆、代码段、数据段等等都是相对于应用程序而言的。

5.类的成员变量在位于数据段中一直占用内存。而类的方法却是该类的所有对象共享的，只有一套，对象使用方法的时候方法才被压入栈，方法不使用则不占用内存。

相关网站：
http://blog.csdn.net/yangyuankp/article/details/7651251

 

转载于:https://www.cnblogs.com/clever765/articles/6994736.html