JAVA面向对象总结(一)

1.1.面向过程

本质

是功能分解,是围绕实现处理的功能的”过程”来构造系统的。

特点

通过自顶向下，逐步求精，模块化的方法来实现程序功能

开发效率高，但软件耦合度高

无法适应快速业务变化，不适合做大型面向客户应用的开发

1.2.面向对象：

本质

是抽象, 封装对象的特性与行为，进而考虑对象之间的联系。

特点：

站在符合人的思维习惯的角度进行程序设计

高内聚、低耦合，重用性高

适应于解决当今的庞大、复杂和易变的系统模型。

什么是面向对象：

是一种充分利用抽象，继承，封装，消息等方法与概念将现实世界要解决的问题抽象成为一个个的对象，从而模拟客观世界的一种程序设计方法。

 

面向对象更加强调运用人类在日常的思维逻辑中经常采用的思想方法与原则，如抽象、分类、继承、聚合、多态等。

好处：重用性、扩展性、稳定性

 

分为三大点：
面向对象分析(Object Oriented Analysis)、面向对象设计(Object Oriented Design)、面向对象的编程实现(Object Oriented Programming)

 

类：类是具有共同特征的一类事物的抽象，类中定义了这一类事物所共同持有的属性和方法。

对象：是某一个类型的具体实例，类可以看成对象的一个模版。而对象就是依照这个模版生产出来的产品

类是对象的抽象，对象是类的实例



类与类之间的关系：

1.关联：一个类要用到另一个类

2.继承：什么是一种什么

3.聚合（聚集和组合的简称）：什么是什么的一部分

   聚合又分成两类

3.1.聚集：单个和整体没关联，比如一个寝室由四个人聚集而成，每一个人都不是这个寝室必不可少的部分，因为可以换寝室啊

3.2.组合：单个和整体有依赖关系，比如一个人有头和身体组合而成，头是人必不可少的部分

      当然如果需要细分的话还有实现，多态这些关系

匿名内部类

    可以使用匿名内部类的地方：任何需要子类／实现类对象的地方，当实现类只用一次的时候可以使用匿名内部类。

创建匿名内部类：return new InterfaceB(){//匿名内部类

                              public void move(){

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

                              }

                        };

                new+接口名／父类名+(){

                覆盖方法／实现方法;

                }

 

Java对象的生命周期：
1） 为对象分配内存
2） 初始化属性
3） 调用何时的构造函数
4） 在程序中使用对象
5） 在内存中分离对象的引用和对象
6） 在某个时刻，运用java的垃圾收集程序并查看那些内存不再使用
7） 垃圾收集程序释放内存

 

结构化程序设计: 程序＝算法＋数据结构

面向对象程序设计: 程序＝对象＋消息传递

 

面向对象的三个特征：封装，继承，多态

 

封装：

    含义：

1.把对象的全部属性与全部服务，封装为不可分割的单元。

2.尽可能隐藏对象内部的细节

3.提供适当的可见性

好处：

    1.通过封装实现重用

    2.降低耦合. 分清责任

    3.内部的实现,自由改变。

 

可见程度依次降低：public-->protected -->默认(friendly)-->private

 

                类本身       同一个包中    子类     不同包

  private        可以        不能           不能     不能

  default        可以        可以           不能     不能

  protected      可以        可以           可以     不能

  public         可以        可以           可以     可以

 

继承：

  为什么要用：代码复用、为了多态

 

重写和重载的区别：

方法的重写Overriding和重载Overloading是Java多态性的不同表现。重写Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Overriding)子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被"屏蔽"了。如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载(Overloading)。Overloaded的方法是可以改变返回值的类型

 

this关键字的用途：

 

指向当前类的Object(对象)的reference(引用)

this基本用途之一：解决命名冲突问题(成员变量与局部变量)

this基本用途之二：调用本类其它构造器this(参数列表)

this基本用途之三：在方法中，需要引用该方法所属类的当前对象时候，直接用this

 

supper关键字的用途：

指向当前类的父类的Object(对象)的reference(引用)

super基本用途之一：访问直接父类中被屏蔽的成员变量用

super基本用途之二：子类构造方法调用父类构造器

 

多态：

含义：

     表达基类与子类之间，不同子类之间，对同一范畴的行为，表现出不同的形态，这一种特性，就是多态性

本质：将子类对象，可作看成父类对象来看待

  好处：接口重用！接口与实现分离

将what（是什么）从how（怎么做）中抽离

 

 

抽象类和接口

1.       抽象类就是一个残缺不全的类，它其中提供的未实现的方法叫抽象方法，（所以他不能直接实例化）它的存在意义在于它强制要求子类重写它的抽象方法，从而实现多态.

 

抽象类中可带“普通方法”，抽象类中，也可完全不带抽象方法。但含有抽象方法的类必须被声明为抽象类。

  2.接口是一种特殊的抽象类，这种抽象类只能包含常量和方法的定义，而没有变量（虽然你写出来像成员变量，但是编译器最终自动加上public static final），也没有方法的实现，也不能有构造方法

  3.接口的修饰符不自动加上public也就是说如果没有加上这个修饰符，在其他包下面是无法访问该接口的,但是(如果在没有写全的情况之下)接口中的常量自动为public staitc final,接口中的方法自动为public abstract

  4.注意一点很重要的问题，接口中不允许使用静态块，所以里面的常量在申明的时候就必须要给初始值

  5.从设计层面上讲：当注重什么是一种什么的时候使用抽象类，当注重什么能做什么的时候使用接口

  6.还有就是一个类可以实现多个接口，但是不能继承自多个抽象类

  7. abstract的method不能同时是static或native或synchronized或final

 

面向对象复用方式：

组合:在新的类定义中,生成已有类的对象.这种方式称为”组合”,因为新类,由已存在的class的对象组成.

继承:通过继承的语义,直接继承现有类的特性.这是跟组合,不一样的方式

实现:对统一的规范,进行实现.也是复用的一种方式

 

组合&继承&实现:

Is a关系

Has a关系

Like a关系

 

Java是值传递

 

对于简单类型数据：传递的是数据值（数据值的一份copy）；

对于引用类型数据：传递的是地址（地址的一份copy），此时，地址，就是这个变量的值。

 

无论哪种数据类型，参数传递，都是对其值的一份Copy,因此Java参数传递的方式是值传递。

 

static关键字

 

能修饰：成员变量、成员方法、游离代码块、内部类

不能修饰：局部变量、构造方法

static关键字声明一个属性或方法是和类相关的，而不是和类的某个特定的对象(实例)相关的，因此，这类属性或方法也称为“类属性”或“类方法”，能够被所有类的实例共享。

注：static方法中，不能直接调用非static成员变量或成员方法,反之则可

 

finally关键字

 

final称为修饰符，它可以修饰:

成员变量、成员方法、类、局部变量,方法参数（极少用）

不能修饰：构造方法

 

因为都牵涉到一个“不可变性”，所以常叫最终变量，最终方法，最终类．

 

final修饰的成员变量,必须自己显式进行初始化.(创建时或在构造方法中)

 

八个修饰符比较

修饰符    类    属性   方法   局部变量

static           Y      Y        

final      Y     Y      Y       Y

abstract   Y            Y    

public    Y      Y      Y      

protected        Y      Y

default    Y     Y      Y

private          Y      Y

 

 

JAVA数据类型

    基本数据类型：1.数值型(1)字节型 byte 1个字节 -128~127之间的整数

                         (2)整型 int 4个字节 -2的31次方~2的31次方-1

                         (3)短整型 short 2个字节 -2的15次方~2的15次方-1

                         (4)长整型 long 8个字节 (声明long型时要再最后加个L)

                             -2的63次方~2的63次方-1

                         (5)单精度浮点型 float 4个浮点字节近似存储

                             (同样声明float型时要在最后加大写或小写f)

                         (6)双精度浮点型 double 8个浮点字节近似存储

                             (精确度比float高)(位数越高，精度越高)

                  2.字符型 char 定义char要用单引号，

                           例：char c='中国'；

                           要将变量定义为单引号时，要将单引号前加入/，例：

                           char c5='/'',转义字符有/b、/t、//等。

布尔型 boolean Boolean值只有true和false（在C/C++中，0

0代表false而非0代表true，在JAVA中则不一样。）

     引用类型：1.类

               2.接口

               3.数组

 

String类的特征：（本质上是一个char类型的数组）

    池化思想：当建立String s1=”hello”；时，jvm会在对象池中查找有没有”hello”这个字符串，没有就直接创建一个，存放给String所存放的对象。

当频繁进行字符串拼接的时候，要使用StringBuffer中的参数append来进行实现。

 

包装类：包装基本数据类型为什么要提供包装类？因为有一些结构要求只能用对象，所以要将基本数据类型包装成类才可以在这些类中调用。

 

反射：记录了类的DNA信息，可以通过反射来探察出类的明细信息，也可以使用元对象访问每个类对象的属性和方法，甚至私有的属性和方法。

Class类：Class c= Person;

         创建一个Person类的元对象。

获取一个类的元对象(1)通过类名字符串获取类的元对象

                    Class c=Class.forName(“Person”);

                  (2)通过类本身获取类的元对象

                    Class c=Person.class;

                  (3)通过一个对象获取类的元对象

                    Person p=new Person();

                    Class c=p.getClass();

 

 

 

线程：

 

线程：系统内部完成某个确定任务的应用程序。一个进程，有多个线程，每个线程完成一个确定任务的主线。

 

进程：每一个独立执行的应用程序，完成某个确定任务的应用程序。

 

Thread类:需要定义run方法。

 

时间片：系统分配给一个线程运行的时间。一个线程的时间片用完就会调度其他线程。

 

Runnable接口：类实现Runnable接口后要实现run方法，同时要将主方法中调用类构建线程对象的时候要用构造方法来实现运行线程。

               如：Thread t3=new Thread(new Thread3());

               (有被CPU调用的机会)

               使用t3.start();来启动线程。

线程三要素：CPU、code(代码)、data(数据)

     CPU：调度线程

     代码：告诉线程是做什么，run方法

     数据：代码所要操作的

 

线程分类：1.不共享代码，也不共享数据

          2.不共享代码，共享数据

          3.共享代码，不共享数据

          4.共享代码，共享数据，但是不安全，所以要加锁

            synchronized(obj){}申请obj对象的锁标记(每个对象都有一个锁标记，而且每个都是唯一的)，

                              只有获得锁标记才能执行{}里的代码，执行完代码后会释放锁标记，如果

                              有下标越界就在{}内加上判断，切记obj要为static。

new Thread     －→Runable     －→Running(付给时间片))

t.start(新建线程)   (可运行状态)      (运行时状态)   

启动线程              ↑              |

                      ｜             ↓

                      ｜          lock poul(锁池：每个对象都有一个锁池)

                       －－－－－obj(t2,t3,t4)

 

每个线程都有执行的机会，当进行一些深度运算的时候，一直占用CPU资源，会耗费很多时间，所以才需要用到线程。

 

当synchronized 修饰方法是，表示对当前对象加同步锁，该对象其他所有的synchronized 方法都不能被调用，直到第一个方法执行完毕比释放当前对象的锁。建议不要嵌套多个synchronized方法，或造成死锁问题。

wait语句：让正在执行的线程暂时终止掉，进入对象的等待池中去等待，并释放掉对象的锁。一定要用在有synchronized的代码块内。使用notifyAll()来唤醒对象的等待池中的所有线程对象，使用notify()就对对象的等待池中的某个线程对象进行唤醒。

 

Runable －－－－→Running(付给时间片)－－－－－－→wait poul(等待池：每个对象的都有一个等待池)

(可运行状态)      (运行时状态)                           |

   ↑              |                                    | (去拿锁) 

   ｜             ↓                                   |

   ｜          lock poul(锁池：每个对象都有一个锁池)←—

    －－－－－obj(t2,t3,t4)

 

Thread里的join方法：阻塞调用线程，直到调用join方法的线程终止为止。用于当某个线程的工作特别紧迫的时候，让这个线程现完成工作再调用其他线程。

 

欢迎大家来相互学习,本人最近将发布J2EE方面的相关总结,希望大家能多多支持!