java的面向对象

面向对象

1.面向过程和面向对象的区别：

比如我要回家，我就要开车门，发动发动机，挂档，踩油门这是面向过程；面向对象就是我回家，我命令车回家就可以，关于车怎么去的我们管不着，信息封装在车这个类里面，不用了解车整个开动过程。

2.类是用于描述同一类形的对象的一个抽象概念，

（1）具有共同事物的特征抽象，类中定义了这一类对象所因具有的静态和动态属性。类是可以看成一类对象的模块，对象可以看成该类的一个具体实例。（比如：同学是个类；对象：林虎同学就是对象）

（2）属性和成员变量是一回事。实例和对象一回事

3.看是否是继承关系你可以用XXX是一种ＸＸＸ，如果能解释通就是继承关系

类和对象之间的关系：继承关系（一般和特殊），聚合关系（整体和部分），关联关系，实现关系，多态

4.看是否是聚合关系：ＸＸ是ＸＸＸ的一部分，如果符合就是聚合关系

5.作为面向对象去编程时要点，

第一点：不应该考虑第一步干什么，第二步干什么，而是应该考虑这个问题要解决时有哪些类，有哪些对象；第二点：考虑每一种对象，每一种类应该具有哪些属性和方法；第三点：考虑类和类之间有什么关系

6.必须先定义类才能有对象：

（1）对象是ｊａｖａ的核心，在ｊａｖａ程序中“万事万物皆对象”；对象可以看成是静态属性（成员变量）和动态属性（方法）的封装体；类是用来创建同一类型的对象的“模板”，在一个类中定义了该类对象所应具有的成员变量以及方法

（2）一个组件好多个对像，还有就是面向对象会走向面向组件

 

（3）类的定义：声明，定义，才能使用

（4）成员变量可以是java语言中任何一种数据类型（包括基本类型和引用类型）

7.成员变量的作用范围为整个类体

（1）【在java语言中除了基本类型之外的变量类型都称为引用类型，java中的对象是通过引用对其操作的。】

（2）引用相当于C或者C++里的指针，引用是一小块内存指向一大块内存。

（3）构造方法和new一起用的，而new是调用构造方法才能创立一个新的对象

方法的局部变量用完后就会释放不会去占用内存.

（4）成员变量没有初始化，系统会自动帮他初始化的，那个局部变量就不可以。堆内存是动态分配内存的，对象new出来的东西就是放在堆内存里的，当没有指定构造函数时，编译器为类自动添加类名（）{}的构造函数.

（5）在java中“+”为字符串连接符

8.约定俗成的命名规则：1.类名的首字母要大写；2.变量名和方法名的首字母小写

                    3.运用驼峰标识

（1）写构造方法或者函数时，那个方法名必须与类同名，没有返回值；生成特定的对象时要有构造方法。先构造方法再对对象进行设置方法。

9.Public static void main (String[] args)为入口函数；调用方法时用上【对象名】.方法名

注意：

1【p.setX(5.0);

p.setY(4.0);

p.setZ(3.0);

System.out.println(p.getDistance(p2))】

2【Point p3 = new Point(5.0,4.0,3.0);

Point p2 = new Point(1.0,1.0,1.0);

System.out.println(p3.getDistance(p2));】

对什么值（或者什么对象）进行方法调用时，就用该数值(或者对象)加（.）加方法名在加（你传入的另一个对象）就像这两个例子一样。

（2）在设置方法时，应该对方法名进行运用驼峰标识比如【void setX(double _x)】

9.方法的重载：

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

（2）方法的重载和构造方法的重载其实是差不多的，只是那个构造方法的重载是在构造方法时进行重载；

（3）只有在方法名一致,参数（类型不一样或者个数不一样）不一致时才可以用到重载

10.对象的创建和使用：

（1）必须使用new关键字创建对象

（2）使用对象引用.成员变量或来引用对象的成员变量。

（3）使用对象引用.方法（参数列表）来调用对象的方法。

（4）同一类的每个对象有不同的成员变量存储空间。

（5）同一类的每个对象共享该类的方法。（非静态方法是针对每个对象进行调用）

（6）堆栈,队列,树比较重要,所以必须学好

11构造函数的作用：

（1）对象初始化，调用构造函数是在创建对象时赋予其初始值，从而保证对象在使用前有正确的初值。

（2）引入更多的灵活度（变量赋值或更复杂的操作）。构造函数是类的一种特殊的方法，函数名字必须和类名相同，但可以携带不同的参数，因此，可以通过给构造函数设置不同的自变量，也就是通过方法的重载（overload）来为一个类提供多个不同的构造函数，为类的不同对象附不同的初始值。

（3）java语言中可以不定义构造函数。Java语言中每一个类都至少有一个构造方法，如果类的定义者没有显示地定义任何构造函数，系统将自动提供一个默认的构造函数：

      .默认构造方法没有参数。

      .默认构造方法没有方法体。

.Java类中，一旦类的定义者显示的定义了一个或多个构造方法，系统将不再提供默认的构造方法。

（4）对于方法的前面没有static的，要调用这个方法时就必须用new ，new出个对象才能调用，因为这个方法只有针对某个对象才能对其进行调用，（静态方法是对对象进行特殊化的操作吧！个人见解）

>>遇到复杂表达式时从内到外分析

>>方法的返回值存在一个临时的区域里面.

12.This 关键字的用法：

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

（2）当必须指出当前使用方法的对象是谁时要用this。

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

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

（5）你对哪个方法调用时this就是指的哪个对象。当你确定不了你的参数为哪个变量时，或者说你不知道你的参数是哪个对象的变量时，找最近那个变量，用到this（这个叫最近申明原则）。【其中this指向当前对象】

This是指向对象自己。

13.static 关键字：

（1）在类中，用static声明的成员变量为静态成员变量（公用变量），它为该类的公用变量，在第一次使用时被初始化，对于该类的所以对象来说，static成员变量只有一份。

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

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

（4）可以通过对象引用或类名（不需要实例化）访问静态成员（静态变量存放在数据区域）

（5）对方法而言，static一项重要的用途就是帮助编程人员在不必创建对象的前提下调用static修饰的方法（静态变量属于整个类的，任何一个对象都可以访问这个值）。(字符串常量也是存放在data域中)，（静态变量static可以作为计时器）

14.package和import语句的用法：

（1）为便于管理大型软件系统中数目众多的类，解决类的命名冲突问题，java引入包（package）机制，提供类的多重类命名空间。（package必须写在源代码的第一行，指明该文件中定义的类所在的包。）格式：

        Package pkg1[.pkg2[.pkg3]];

（2）在打包时约定俗成的方法是：将打包的域名倒过来。（可以有效的避免类名的重复）。

（3）java编译器把包对应于文件系统的目录管理，package语句中，用‘.’来指明包（目录）的层次。如果你想把一个类放在包里面，那么就在源码区的第一行写上package，编译出来的类必须位于正确的目录下面

（4）编译出来的类必须位于正确的目录下面。（1.如果你想将一个类放在包里面的话，那么就应该首先在类名前面写上package，在package后面你想跟多少层包就可以放多少层的包，生成的class文件要放在正确的目录下面，所谓的目录就是和包的层次一样的目录。2.在另一个类里面用我们定义好了的类，必须将名字写全了。3.用import（引入就不需要每次写那么长的类名了），直接在另一个类里面用import+包名+*就可以了。，‘*’号的意思是说这个包里的类都引用进来了）

》》对于在包外的编译的文件要访问包内的类，必须配置环境变量，在配置的时候classpath路径应该在最上层包的父目录下，只有这样系统才能找到编译的类。

》》执行一个类必须写全包名。

15.J2SDK中主要的包介绍

（1）java.lang 包含一些java语言的核心类，如String，Math，Integer，System和Thread，提供常用功能（这个包的类对于编写java程序不需要引入，可以直接用这个包的类，而对于其他包中的类必须引用才能使用该包中的功能，比如下面的包：）

（2）java.awt 包含构造抽象窗口工具集（abstract window toolkits）的多个类，这些类被用于构造和管理应用程序的图形用户界面（GUI）。

（3）java.applet 包含applet运行所需的类

（4）java.net  包含执行与网络相关的操作的类

（5）java.io 包含能提供多种输入/输出的功能

（6）java.util 包含一些实用工具类，如定义系统特性，使用和日期日历相关的函数【其中这些包都位于安装的JDK中的包内的jre中，打开jre中有一个lib文件，里面有一个rt.jar文件，用winRAR acherve解压，里面java中都有这些包】

》》》那么如何让自己定义的类变成jar文件，可以直接让用户使用你呢：

…在命令提示符中输入jar-cvf test.jar(对你的jar文件命名为test.java)*.*。其中*.*意思是说将目录下的类全部打包。【注意在生成的jar包时，路径必须切换到包的最外层类的上一个文件夹。

16.继承和权限控制：

你在源文件里用了package，那么那个路径就不能变化。

（1）在java中使用extends关键字来实现类的继承机制，语法<modifier>class<name>[extends<superclass>]{….}

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

（3）java只支持单继承，不允许多继承：

            …一个子类只能有一个基类 一个基类可以派生多个子类

（什么是什么）代表是一种继承关系。

>>>访问控制符有（private，public，protected，default）【其中private的访问权限在类内部,即使是子类都不可以访问，default在类内部和同一个包，protected在类内部和同一个包还有就是子类，public在任何地方都可以访问】17.方法的重写(重载是在本类中构建方法而重写是子类对父类的方法进行完善)

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

（2）重写方法必须和被重写的方法具有相同方法的名称，参数列表和返回类型

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

18.为什么要进行方法的重写呢？

其实想想啊，那个从父类继承过来的方法很有肯能满足不了子类的应用，所以进行方法的重写对子类的定义更全面。【就像在父类中的动物在跑的类一样，对于子类猫在跑，猫在跑的时候继承了父类动物在跑的方法，但是继承过来以后，猫横有可能跑起来有响声，但是事实是猫有肉垫不会发出响声的，所以就必须对跑的方法进行重写】

19.当你重写一个方法时记得最好去复制过来，

以防写错字母，如果写错了，就可能达不到预期效果【再用方法的重写时，方法名与父类必须一致，不然不能达到理想的效果】。

20.在java中用super关键字去访问基类的成分。

（1）this是指向当前对象，而super是当前对象里面的基类（父类）的引用。

（2）当new一个子类对象时，内存里会自动分配父类对象，其中super是用来调用父类的方法或者一些成分的

21.继承中的构造方法

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

（2）子类可以在自己的构造方法中使用super(argument_list[参数列表])调用基类的构造方法【使用this（argument_list[参数列表]）调用本类的另外的构造方法】。如果在子类中调用父类的方法时,使用super调用时，必须先写在子类构造方法的第一行（就像你上战场打仗一样你必须从长官里拿到枪才能去杀敌，自己凭空new一把枪出来只是你脑子里的枪，并没有赋予它杀敌的功能，等你死了以后再去问长官拿枪就没什么意思了，就会报错）

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

（4）如果子类构造方法中既没有显示调用基类的构造方法，而基类中也没有无参的构造方法，那么编译会出错。

22.JDK-API文档查询：

 …object类：

（1）object类是所有java类的根基,他是所有类的老祖宗。【所有的数据和数组都实现了这个Object类的方法】

（2）如果在类的声明中没有使用extends关键字指明基类，则默认基类为object类：public class Person{

                            ……

}

   等价于：

     Public class Person extends Object{

………

}

（3）Object类在上面所提到的那个rt.jar中，只要解压以后就能找到。

（4）Object类有个空的构造方法，为什么要这个空的构造方法呢？其实在我们写java程序时，构造类的时候，任何类都默认从Object类中继承，所以在写各个方法时也都默认重写Object类方法，如果不用super关键字声明，那么重写的方法默认调用无参的Object类的构造方法。只有在Object类的构造方法为空的时候，程序构造方法默认调用无参数的Object的构造方法，如果不为空，那么系统自己会报错。

（5）getclass()有反射的机制，意思可以拿到自己已经构造好的class

23.toString方法：

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

（2）在进行String类型和其他类型数据的连接操作时（如：System.out.println(“info”+person)，将自动调用该对象类的toString()方法

（3）而且可以根据需要在用户自定义类型中重写自定义类型方法。

（4）任何一个类从Object类中继承下来都可以重写toString()d的方法。当你和字符窜相连接或者打印出来的时候，那么它会返回一个代表你正确编辑的信息字符串。

24.-hashcode的解释：

由于许多类会在java虚拟机中，当某些类运行的时候，那么java虚拟机就要找到这些类的地址来，那么怎么找这些类的地址呢？java虚拟机会用hashcode table 表去记录各个类的地址，而这张表用hashcode编码来记录。通过hashcode去找到你使用的类

25.Object类之equals：

（1）equals可以比较两个对象中在内存中存储的内容是否一样（指示其他某个对象是否与此对象“相等）

（2）用object类中equals方法时，创立的比较对象不能为空值。

（3）在用equals 方法时，必须重写object类中equals的方法，形式：public Boolean equals(Object obj),提供定义对象是否相等的逻辑。

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

（5）j2sdk提供的一些类，如String，Data等，重写了object的方法，调用这些类的equals方法时，x.equals(y),当x与y所引用的对象是同一类对象属性内容相等时（并不一定是相同的对象）返回true否则返回false。

（6）而且可以根据需要在用户自定义中重写equals用法。当不知道你用的对象类型是否有equals方法时可以到API文档查找。

26.对象转换（casting）：

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

（2）一个基类的引用不可以访问其子类对象新增加的成员（属性和方法）。只能看到子类继承基类的成员变量不能访问子类新增的成员，（就像门缝里看人，看的只是一部分）。

（3）可以使用引用变量instanceof（是不是什么之一）类名 来判断该引用型变量所“指向”的对象是否属于该类或该类的子类。

（4）子类的对象可以当做基类的对象来使用称作向上转型（upcasting），反之称为向下转型（downcasting）。

（5）对象转换是得java编程的时候可扩展性比较好，对以后编程更加的方便。

27.多态：

（1）如何让java程序的可扩展性最好呢？在面向对象里最核心的机制就是动态绑定和多态

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

28.多态实行的必要条件：

(1)程序要有继承

(2)方法要有重写

(3)父类引用指向子类对象

(4)实际中调用的什么方法就是什么方法，不是引用类型的方法。New的什么对象就调用那个对象重写的方法，只有在运行的时候才知道对象的绑定是谁的方法，所以叫动态绑定。实际中new的什么对象就调用这个重写的方法。

29.抽象类：

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

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

(3)抽象类不能被实例化。当一个类中有抽象类的方法时那么这个类也必须声明为抽象类。

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

(5)抽象的方法相当于C++里面的虚函数。抽象方法就是用来被重写的，便于用来动态绑定。

30.Final关键字：

(1).Final的方法不能够被重写,final的作用使得各个类或者变量，方法被固定死

(2).Final的变量的值不能够被改变（Final的成员变量，Final的局部变量）了，很难改变。

(3)final的类不能够被继承。比如final int i=8;一旦i被初始化为8的时候，那么i的值不会改变。Final相当于C++里面的const

31.接口：

(1)多个无关的类可以实现同一个接口，前提这几个类要有相同的共性。

(2)一个类可以实现多个无关的接口。可以解决java中单一继承的局限。

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

(4)定义java类的语法格式：

        《modifier》class <name>[extends<superclass>]

          [implements < interface>[,<interface>]*]{

<declarations>*

}

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

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

32.接口的特性：

【1.接口可以实现多重继承；2.接口中声明的属性默认为：public static final的；也只能是public static final的；3.接口只能定义抽象方法，而且这些方法默认为：public的，也只能是public的，4.接口可以继承其他的接口，并添加新的属性和抽象方法。3.子类在继承基类的同时还能够接多个接口，解决单个继承问题；4.接口与接口之间可以实现继承，而类只能对接口里的方法进行实现】