JAVA（一）JAVA基础/面向对象基础/高级面向对象

成鹏致远 | lcw.cnblog.com |2014-01-23

JAVA基础

1.开发环境搭建

  1. JAVA程序的执行流程
    1. JAVA命令->要使用一个*.class文件(类文件)->通过classpath找到*.class文件所保存的真实目录，之后再进行加载执行
  2. 小结
    1. Path的主要功能是设置JDK的可执行命令
    2. classpath主要是在执行时候起作用，告诉JVM类的保存路径，一般设置成“.”
    3. 【注意】classpath只在java命令的时候起作用，而对于javac不起任何作用

2.简单JAVA程序

  1. 使用Public class和class声明的区别
    1. public class文件名称必须与类名称一致
    2. class文件名称可以与类名称不一致
  2. 在整个java中只允许有一个public class声明，但是允许有其他的class声明
  3. 在使用一个java文件中允许有多个class定义，编译之后会自动划分不同的class
  4. 【注意】在编写java程序的时候类名称的编写要采用一定的格式：所有单词的首字母必须大写
  5. 小结
    1. public class及class的声明：一个java文件中只能有一个public class的声明，但是允许有多个class，使用的时候直接要使用主方法所在的类
    2. 关键字的表示
    3. 标识符的命名规则：最好永远以字母开头，不使用偏门的字符
    4. 常量就是不可改变的数值，变量的内容是可以改变的

3.java基础程序设计

  1. 数据类型
    1. 基本数据类型
    2. 数值型
      1. 整数类型（byte、short、int、long）
      2. 浮点类型（float、double）
    3. 字符型（char）
    4. 布尔型（boolean）
    5. 引用数据类型
      1. 类（class）
      2. 接口（interface）
      3. 数组
  2. 分为两大类型
    1. 基本数据类型：类似于普通的值
    2. 引用数据类型：传递的是内存的地址
  3. 浮点类型实际上就是表示小数
  4. Double类型可以装全宇宙的数据
  5. 对于数据来说，设置内容的时候应该放在整个允许的范围之中。如果超过了此范围，则肯定会出现数值不正确的情况
  6. 字符类型
    1. 字符类型在内存中占有2个字节，可以用来保存英文字母等字符。
    2. 计算机处理字符类型时，是把这些字符当成不同的整数来看待，因此，严格来说，字符类型也算是整数类型的一种
  7. 所有数据类型都会像字符串转换
  8. 小结
    1. Java中的数据类型划分
    2. 八种基本数据类型，包括长度的，常量的默认值
    3. String，任何类型都会向String进行转换

4.运算符、表达式与语句

  1. 小结　
    1. 清楚的掌握JAVA中的赋值、计算、关系运算符
    2. 了解一下位的运算
    3. 使用括号可以轻易的改变运算的优先级

5.判断与循环语句笔记

  1. 在使用switch进行表达式的时候一定要注意：在表达式中只能使用数字或字符或枚举
  2. 小结
    1. 任何语言都会包含三种功能：顺序、选择、循环
    2. 选择结构：if/if..else/if..else if..else/switch
    3. 循环：while/do..while/for
    4. 两种中断关键字：break/continue

6.数组与方法

  1. 数组定义及使用
    1. 要使用Java的数组，必须经过两个步骤
      1. 声明数组
      2. 分配内存给该数组
    2. 数组声明后实际上是在栈内存中保存了数组的名称，接下来便是要在堆内存中配置数组所需要的内存，其中“长度”是告诉编译器，所声明的数组要存放多少个元素，而“new”则是命令编译器根据括号里的长度开辟空间
    3. 变量的命名规则，第一个单词的首字母小写，之后每个单词的首字母大写
    4. 【堆栈内存的解释】数组操作中，在栈内存中保存的永远是数组的名称，只开辟了栈内存空间的数组是永远无法使用的，必须有指向的堆内存才可以使用，要想开辟新的堆内存则必须使用new关键字，之后只是将此堆内存的使用权交给了圣洁的栈内存空间，而且一个堆内存空间可以同时被多个栈内存空间指向，即：一个人可以有多个名字，人就相当于堆内存，名字就相当于栈内存
    5. 小结
      1. 数组的使用分为两个步骤
        1. 声明数组：是要栈内存中声明的
        2. 为数组开辟空间：是使用关键字new在堆内存中完成
        3. 当然也可以一起完成：数据类型 数组名称[]=new 数据类型[长度]
      2. 可以通过数组名称.length的形式求出数组的长度
      3. 数组中有很多常见算法及题目，只要控制好其下标就可以完成
      4. 数组下标不能越界，越界之后程序会出现错误，如果开辟了3个空间，则下标：0~2
      5. 数组的维数在开发中最多基本上就使用到二维，就相当于是一个表格
      6. 多维数组因为其比较复杂，所以不建议使用过多
  2. 方法的声明及使用
    1. 方法重载
      1. 方法的重载就是方法名称相同，但参数的类型和参数的个数不同，通过传递参数的个数及类型不同以完成不同功能方法调用
      2. 方法重载一定是根据参数的类型或个数来判断的
    2. 小结
      • 方法定义的时候如果需要返回值，则明确写出返回值的类型
      • 在方法中可以进行重载：方法名称相同，参数的类型或个数不同，称为重载
      • 在方法中可以使用return来结束一个方法的操作
      • 方法自己调用自己，成为递归操作，递归操作中必须有明确的结束条件
  3. 数组的引用传递
    1. 小结
      1. 数组的引用传递传递的就是堆内存的使用权，可以将一个数组传递到方法之中，传递的时候不需要写上“[]”，直接写名字即可
      2. 方法中对数组所做的修改都会被保留下来
      3. 在java中提供了一些对数组操作支持的方法，这些方法慢慢都会有所介绍
  4. Java新特性对数组的支持
    1. 所有的可变参数接收之后都是以数组的形式保存下来的，所以直接按数组的方式接收即可
    2. 小结
      1. 可变参数在开发中经常用到，尤其是在进行一些其他引用数据类型使用可变参数的时候
      2. foreach不光可以输出数组，在日后的类集中也是对其有输出的能力的

面向对象基础

1.面向对象大特征

  1. 封装：对外部不可见，可以保护程序中的某些内容
  2. 继承：扩展类的功能
  3. 多态：方法的重载/对象的多态性

2.类与对象

  1. 类属于引用传递类型，从数组中可以知道，引用数据类型必然存在栈内存->堆内存的引用关系，实际上在类与对象的使用上依然存在这样的关系
  2. 声明对象：在栈内存中声明，与数组一样，数组名称就保存在栈内存之中，只开辟了栈内存的对象是无法使用的，必然有其堆内存的引用才可以使用
  3. 对象是保存在栈内存之中，属性是保存在堆内存之中，在程序中所有的方法是保存在全局代码区之中的，此区中的内容中所有对象共享的
  4. 【注意点】在使用对象的时候，对象必须被实例化之后才可以使用（实例化对象，并不单单指的是直接通过new关键字实现的，只要其有堆内存的空间指向，则就表示实例化成功），如果不实例化，则会出现运行时错误：空指针
  5. 所谓的引用数据类型，实际上传递的就是堆内存的使用权，可以同时为一个堆内存空间定义多个栈内存的引用操作
  6. .小结
    1. 掌握栈与堆内存的关系
    2. 对象保存在栈内存之中，而具体的内容保存在堆内存之中
    3. 对象间的引用传递，实际上传递的就是堆内存被单的使用权
    4. 垃圾的产生

3.封装性

  1. 为什么要有封装
    1. 封装就是保护内容
    2. 保证某些属性或方法可以不被外部看见
  2. 访问封装的内容
    1. 封装的属性肯定是要表示出一些实际的意义，那么这些意义的内容肯定应该由外部设定，所以在整个JAVA中对于封装性的访问就给出了一个明确的原则，此原则必须遵守
    2. 被封装的属性如果需要被访问，则需要编写setter及getter方法完成（setter方法完成输入验证，getter方法只是把内容简单的取回即可）
  3. 封装的类图表示
    1. 用“-”表示private
    2. 用“+”表示public
  4. 小结
    1. 封装性的目的
    2. setter及getter方法的作用
    3. 封装性在JAVA中有很多形式，private只是最基本的一种形式，也是一种比较觉的形式
    4. 类中的每一个属性必须封装

4.构造方法与匿名对象

  1. 只要一有对象实例化则就会调用构造方法
  2. 构造方法声明原则：
    1. 构造方法的名称必须与类名称一致
    2. 构造方法的声明处不能有任何返回值类型的声明
    3. 不能在构造方法中使用return返回一个值
  3. 构造方法的主要目的就是为类中的属性初始化
  4. 构造方法本身与普通方法一样，都是支持重载操作的，只要参数的类型或者个数不同，则就可以完成重载操作
  5. 匿名对象
    1. 匿名：没有名字，在JAVA中如果一个对象只使用一次，则就可以将其定义成匿名对象
    2. 所谓的匿名对象就是比之前的对象少了一个栈内存的引用关系
  6. 小结
    1. 构造方法的定义及使用原则
    2. 对象在实例化时必须调用构造方法
    3. 每个类中都有至少一个构造方法
    4. 匿名对象：只开辟了堆内存的实例对象

5.String类

  1. 字符串判断
    1. “==”使用的判断相等，是判断地址空间是否相等，判断的是地址值
    2. 如果要想判断其内容是否相等，则就必须使用String类中提供的eauals()方法完成，开发中比较常用
  2. 使用直接赋值的方式，可以有效的俭省内存
  3. 使用直接赋值的方式只需要一个实例化对象即可，而使用new String()的方式则意味着要开辟两个内存对象，开发中最好使用直接赋值的方式完成
  4. 字符串的内容不可改变
    1. 实际上字符串内容的改变，改变的是内存地址的引用关系
  5. 小结
    1. String要使用直接赋值的方式，因为使用new会开辟两个空间，造成内存浪费
    2. 一个字符串就是String的匿名对象
    3. 字符串的比较有两种方式：“==”与“equals”

6.String类的常用方法

  1. 字符串与byte数组的转换
    1. byte数组（字节数组），在一般的IO操作中会经常使用到
    2. 在String类中提供了以下的方法可以进行字符串与字节数组间的转换
      1. 字符串->字节数组：public byte[] getBytes()
      2. 将一个字节数组变为字符串
        1. 将全部字节数组变为String:public String(byte[] bytes)
        2. 将部分字节数组变为String:public String(byte[] bytes,int offset,int length)
    3. 在实际操作中，经常会使用到判断一个字符串中是否存在某些内容，可以使用：public int indexOf(String str)，没有则返回-1
    4. 用户输入信息时，可能出现多余的空格，使用trim()去掉字符串左右的空格，但是字符串中间的空格是不可能去掉的

7.引用传递及应用

  1. String是一个特殊的类，其内容不可改变
  2. 只要是符合了引用传递的语法，则可以向任意的地方传递

8.this关键字

  1. 在大部分操作的时候，属性最好都使用this.属性的形式表示
  2. 如果在一个类中有多个构造方法的话，也可以利用this关键字互相调用
  3. 【注意】在使用this关键字调用其他构造方法的时候，有以下几点限制
    1. this()调用构造方法的语句只能放在构造方法的首先
    2. 在使用this调用本类中其他构造的时候，至少有一个构造方法是不用this调用的，否则会出现构造方法的递归调用
  4. this表示当前对象，即当前正在调用方法的对象
  5. 可以使用this和引用传递进行两个对象是否相等的判断
  6. 小结
    1. this.属性/this.方法()，实际上都表示当前的对象中的属性或当前对象调用的方法
    2. this的核心：表示当前对象，当前下在操作本方法的对象称为当前对象
    3. 使用this可以调用其他构造方法，但是此语句必须放在构造方法的首行

9.static关键字

  1. 如果希望一个属性被所有的对象所共同拥有，则可以将其声明为static，声明static类型的属性或方法之后此属性或方法也称为类方法，可以由类名称直接调用
  2. Java中到底有多少个内存区域
    1. 栈内存：可以保存对象的名称（保存，访问的堆内存的地址）
    2. 堆内存：保存每个对象的具体属性
    3. 全局数据区：保存static类型的属性
    4. 全局代码区：保存所有方法的定义
  3. 【注意】使用static方法，不能调用非static的属性或方法
    1. 这一点非常好理解，因为static属性或方法可以在对象没有实例化的时候就直接进行调用了
  4. static相关应用
    1. static属性是所有对象共享的，可以使用static属性统计一个类到底产生了多少个实例化对象
    2. 可以使用stsatic为对象进行自动的编号操作
  5. 小结
    1. 使用static声明属性与非static声明属性的区别
    2. 使用static声明的属性或方法可以直接由类名称调用
    3. 使用static方法的时候一定要注意，只能访问static声明的属性或方法，而非static声明的属性和方法是不能访问，因为static可以在对象没有实例时就直接调用，而其他的属性或方法必须在对象实例化之后才可以调用

10.代码块

  1. 代码块可以分为四种：普通代码块、构造块、静态代码块、同步代码块（出现在多线程中）
  2. 普通代码块：直接定义在方法中的代码块称为普通代码块
  3. 构造块：将代码块直接定义在类中，则称为构造块
    1. 构造块优先于构造方法执行，且执行多次。只要一有实例化对象产生，就执行构造块中的内容
  4. 静态代码块：直接使用static关键字声明的代码块就称为静态代码块
    1. 静态块优先于主方法执行，如果在普通类中定义的静态块，优先于构造块执行，不管有多少个实例化对象产生，静态代码块只执行一次，静态代码块的主要功能就是为静态属性初始化

11.构造方法私有化

  1. 被私有化构造方法的类，不能在外部直接实例化，只能在内部实例化
  2. 单态设计模式(单例设计模式：Singleton)：如果不希望一个类产生过多的对象的话，则就必须使用单态设计模式，而且使用单态设计模式在JAVA中经常碰到，因为在JAVA的支持的类库中，大量的采用了些种设计模式
  3. 所谓的单态就是入口处（构造方法）限制了对象的实例化操作
  4. 小结
    1. 单态设计模式的核心就是将类的构造方法私有化，之后在类的内部产生实例化对象，并通过类的静态方法返回实例化对象的引用

12.对象数组

  1. 【注意】在对象数组的使用中，数组一定要先开辟空间，但是因为其是引用数据类型，所以数组里面的每一个对象都是null值，则在使用的时候数组中的每一个对象都必须分别进行实例化操作
  2. 数组在使用的时候分为静态初始化和动态初始化，对象数组也一样
  3. 小结
    1. 对象数组中的每个元素都必须单独实例化，否则内容就是null

13.内部类

  1. 内部类存在的特点
    1. 缺点：正常的一个类操作时，在类中最好只定义属性或方法。如果定义一个类的话，则肯定破坏了程序的一个结构
    2. 优点：内部类的最大优点，就是可以方便的访问外部类中的私有属性
  2. 如果一个内部类使用static关键字声明，则此内部类就称为外部类，可以直接通过外部类.内部类进行访问，但是如果要想访问外部类中的属性，则此属性必须是static访问权限的
  3. 一个内部类除了可以通过外部类访问，也可以直接在其他类中调用，但是调用的格式：外部类.内部类 内部类对象 = 外部类实例.new 内部类()
  4. 一个内部类可以在任意的位置上定义
  5. 小结
    1. 内部类在实际的开发中非常有用处，而且经常使用的，一定要熟悉其语法及其优点
    2. 在JAVA系统中也会到处看见使用static声明内部类的情况
    3. 【注意】使用static声明的内部类是外部类，操作的时候要使用“外部类.内部类”的形式访问

面向对象（高级）

1.继承的基本实现

  1. 继承：子类继承父类，可以扩展已有类的功能
  2. 访问限制
    1. 子类是不能直接访问父类中的私有成员的
    2. 子类可以调用父类中的非私有方法，但是不能直接调用父类中的私有成员
  3. 小结
    1. 继承的主要目的：扩展类的功能
    2. Java中一个子类只能继承一个父类
    3. Java中不允许多重继承，但是允许多层继承

2.继承进一步研究

  1. 子类对象实例化过程
    1. 在继承的操作中，对于子类对象的实例化也是有要求的：“子类对象在实例化之前必须首先调用父类中的构造方法之后再调用子类自己的构造方法”
  2. 方法的覆写
    1. 在继承的关系中也存在着方法的覆写的概念，就是指子类定义了与父类中同名的方法
    2. 考虑到权限，即：被子类覆写的方法不能拥有比父类方法更加严格的访问权限
    3. 访问权限大小关系：private<default<public
    4. 所以，如果在父类中使用public定义的方法，子类的访问权限必须是public，否则程序会无法编译
  3. 使用super只是更加明确的说，要从父类中查找，就不从子类找了
  4. 【思考】如果现将父类的一个方法定义成private访问权限，在子类中将此方法声明为default访问权限，那么还叫做覆写吗？
    1. 此时，方法并没有被覆写，而是相当于在子类中又重新定义了一个新的方法出来
  5. 属性的覆盖，主要就是指在子类中声明了父类同名的属性
  6. super表示从子类调用父类中的指定操作
  7. 不管任何时候，子类实例化的时候永远要先去调用父类中的构造方法，默认调用的是无参构造
  8. 【注意】对于this和super本身都可以调用构造方法，而且调用的时候都必须放在构造方法的首行，所以这两个关键字肯定不能同时出现
  9. 小结
    1. 方法的覆写与重载的区别，以及覆写的实现，权限：private<default<public
    2. 子类对象的实例化过程：先调用父类的构造，再调用子类的构造
    3. super与this关键字的区别

3.final关键字

  1. final在java中表示的意思是最终的意思。也可以称为完结器
  2. 可以使用final关键字声明类、属性、方法
    1. 使用final声明的类不能有子类
    2. 使用final声明的方法不能被子类所覆写
    3. 使用final声明的变量即成为常量，常量不可以修改
  3. 【注意】命令要求：使用final声明的变量的字母全部采用大写的形式
  4. 使用static final关键字联合声明的变量称为全局常量
  5. static声明的内容是所有对象共同拥有的
  6. 小结
    1. 在一般的开发中，使用final定义的常量是最多的
    2. 使用static final可以声明全局常量　

4.抽象类基本概念

  1. 抽象类的概念：包含一个抽象方法的类就称为抽象类
  2. 抽象方法：只声明未实现的方法称为抽象方法，抽象方法使用abstract关键字声明
  3. 抽象类的定义及使用规则
    1. 包含一个抽象方法的类必须是抽象类
    2. 抽象类和抽象方法都要使用abstract关键字声明
    3. 抽象方法只需声明而不需要实现
    4. 抽象类必须被子类继承，子类（如果不是抽象类）必须覆写抽象类中的全部抽象方法
    5. 从定义上，抽象类就是比普通类多一个抽象方法而已
    6. 抽象类的定义虽然跟普通类非常相似，但是却不能直接实例化
    7. 抽象类必须有子类，子类必须覆写抽象类中的全部抽象方法
    8. 抽象类类图表示：类名称采用斜体表示一个抽象类
    9. 【注意】
      1. 一个抽象类不能使用　final关键字声明
      2. 抽象类中是允许存在构造方法的，因为抽象类依然使用的是类的继承关系，而且抽象类中也存在各个属性，所以子类在实例化之前肯定是先要对父类进行实例化的
  4. 小结
    1. 一定要掌握抽象类定义格式及使用规则
    2. 抽象类使用的时候一定要有子类，子类仍然使用extends关键字继承一个抽象类，同样会存在单继承。一个子类不能同时继承多个抽象类
    3. 抽象类中绝对不能使用final关键字声明
    4. 抽象类中允许有构造方法，而且完全符合子类对象的实例化过程

5.接口基本概念

  1. 接口可以理解为一种特殊的类，里面全部是由全局常量和公共的抽象方法所组成
  2. 如果一个类中完全是由全局常量（static final声明）和抽象方法组成，就可以将其定义成一个接口
  3. 接口的类图表示：使用一个“○”表示
  4. 与抽象类一样，接口要使用也必须通过子类，子类通过implements关键字实现接口
  5. 接口的使用中也必须有子类，子类必须覆写全部抽象方法，implements关键字实现。一个子类可以同时实现多个接口。则子类如果不是抽象类的话，肯定要覆写接口中的全部抽象方法
  6. 一个接口虽然不能继承抽象类，但是在JAVA中一个接口可以同时继承（extends）多个接口，实现接口的多继承
  7. 小结
    1. 接口是一个特殊的类，只包含全局常量和抽象方法
    2. 【注意】接口中的抽象方法可以不加入abstract，而抽象类中的抽象方法必须有abstract关键字声明
    3. 一个类只能继承一个父类，但是可以同时实现多个接口
    4. 一个接口可以同时继承多个接口，以实现接口的多继承
    5. 接口和抽象类一样，都必须依靠子类
    6. 一个抽象类可以实现多个接口，但是一个接口不能继承一个抽象类

6.多态性

  1. 多态在java中面向对象主要有以下两种主要体现
    1. 方法的重载与覆写
    2. 对象的多态性
  2. 掌握对象多态性之后可以直接应用在抽象类和接口上
  3. 对象的多态性主要分为以下两种类型
    1. 向上转型：子类对象->父类对象
      1. 对于向上转型，程序会自动完成，格式
      2. 对象向上转型：父类 父类对象 = 子类实例
      3. 【注意】通过子类进行父类对象的实例化操作时，如果调用的方法被子类覆写过，则肯定调用被覆写过的方法，并且转型之后，因为操作的是父类对象，所以是无法找到在类中定义的新方法
    2. 向下转型：父类对象->子类对象
      1. 对于向下转型时，必须明确的指明要转型的子类类型，格式
      2. 对象向下转型：子类 子类对象 = (子类)父类实例
      3. 向下转型需要采用强制手段
  4. 如果两个没有关系的对象之间发生了转换关系，则肯定会出现异常
  5. 小结
    1. 对象多态性的概念
      1. 向上转型：自动完成
      2. 向下转型：强制。发生向下转型关系之前必须先发生向上的转型关系
    2. 对象多态性可以解决方法接收参数的问题

7.instansof关键字

  1. 在JAVA中可以使用instancdof关键字判断一个对象到底是哪个类的实例
  2. 在开发中一定要注意，对于向下转型操作最好增加验证，以保证转型时不会发生ClassCaseException
  3. 在程序的开发中重点的设计应该放在父类上，只要父类设计的足够合理，则开发肯定会非常的方便
  4. 一个类永远不要去继承一个已经实现好的类，而只有继承抽象类或实现接口
  5. 小结
    1. instanceof用于判断一个对象是否某个类的实例
    2. 在对象向下转型之前最好使用instanceof关键字进行验证

8.抽象类与接口的应用

  1. 在Java中可以通过对象的多态性，为抽象类和接口实例化，这样再使用抽象类和接口的时候就可以调用本子类中所覆写过的方法了
  2. 通过对象多态性可以发现，子类发生了向上转型关系之后，所调用的全部方法都是被覆写过的方法
  3. 抽象类应用：模板设计
  4. 接口类应用：制定标准
  5. 工厂设计模式
    1. 在JAVA开发中是常使用的一种设计模式
    2. JVM的工作原理：程序 -> JVM -> 操作系统
    3. 主方法：应该就表示一个客户端，主方法的代码越少越好。此时，直接在主方法中指定要操作的子类，如果要更换子类，则肯定要修改客户端，就表示跟特定的子类紧密耦合在一起了，此时应该产生一个过渡端，这个过渡端在程序中就称为工厂设计
  6. 代理设计模式
    1. 所谓的代理设计就是提一个代理主题来操作真实主题，真实主题执行具体的业务操作，而代理主题负责其他相关业务的处理
    2. 就好比生活中经常使用到的代理上网，客户通过网络代理连接网络，由代理服务器完成用户权限，访问权限等与上网操作相关的操作
  7. 适配器设计
    1. 在图形界面上用得非常多
    2. 对于Java程序来说，如果一个类要实现一个接口，由肯定要覆写此接口中的全部抽象方法，如果一个接口中定义的抽象方法过多，但是在子类中又用不到这么多抽象方法的话，则会很麻烦
    3. 此时，就需要一个中间的过渡，但是此过渡类又不希望被直接使用，所以将此过渡类定义成抽象类最合适
    4. 即一个接口首先被一个抽象类（此抽象类通常称为适配器类），并在此抽象类中实现若干方法（方法体为空），则以后的子类直接继承此抽象类，就可以有选择的覆写所需要的方法
  8. 内部类扩展
    1. 一个抽象类中也可以包含一个接口
    2. 一个接口中也可以定义一个抽象类
    3. 从实际的个人的开发角度来讲，此种设计并不是很常见，因为代码的结构有些混乱了
  9. 抽象类与接口之间的关系
    1. No 区别点 抽象类 接口
      1 定义 包含一个抽象方法的类 抽象方法和全局常量的集合
      2 组成 构造方法、抽象方法、普通应运、常量、变量 常量、抽象方法
      3 使用 子类继承抽象类（extends） 子类实现接口（implements）
      4 关系 抽象类可以实现多个接口 接口不能继承抽象类，但允许继承多个接口
      5 常见设计模式 模板设计 工厂设计、代理设计
      6 对象 都通过对象的多态性产生实例化对象
      7 局限 抽象类有单继承的局限 接口没有此局限
      8 实际 作为一个模板 是作为一个标准或是表示一种能力
      9 选择 如果抽象类和接口都可以使得的话，优先使用接口，因为避免单继而的局限
      10 特殊 一个抽象类中可以包含多个接口，一个接口可以包含多个抽象类  
  10. 【重要的提示】
    1. 在开发中，一个类永远不要去继承一个已经实现好的类，要么继承抽象类，要么实现接口，如果接口和抽象类同时都可以使用的话，那么优先使用接口，避免单继承局限
  11. 小结
    1. 抽象类和接口的实例化：通过对象多态性
    2. 抽象类表示一个模板，接口制定的是一个标准
    3. 常见的设计模式：模板设计，工厂设计、代理设计，适配器设计

9.Object类

  1. 在Java中所有的类都有一个公共的父类就是Object类
  2. 对象在打印的时候一定会调用toString()方法，是默认调用的
  3. equals()方法的主要功能是进行对象的比较操作
  4. String本身也是Object类的子类，所以已经覆写了此方法
  5. Object类是所有类的父类，则所有类的对象都可以使用Object接收，但是Object不光可以接收对象，还可以接收任意的引用数据类型
  6. 小结
    1. Object类是所有类的父类，只要是引用数据类型都可以使用Object进行接收
    2. 对象在进行向下转型之前一定要先发生向上转型，要使用instanceof关键字判断
    3. toString()：对象打印时调用
    4. equals()：对象比较时调用
    5. String类也是Object类的子类

10.包装类

  1. 一切皆对象，八种基本数据类型不是对象
  2. 把int包装成一个类，这样就可以以对象的形式操作基本数据类型
  3. Integer、Byte、Float、Double、Short、Long都属于Number类的子类。Number类本身提供了一系列的返回以上六种基本数据类型的操作
  4. Character与Boolean都属于Object的直接子类
  5. 装箱与拆箱
    1. 将基本数据类型变为包装类称为装箱
    2. 将包装类的类型变为基本数据类型称为拆箱
  6. 在JDK1.5版本之后对程序的包装类功能进行了改变，增加了自动装箱及自动拆箱的功能。而且也可以使用包装类直接进行数字运算
  7. 在包装类中，实际上还存在一个最大的特点，就是可以将字符串变为指定的数据类型
  8. 包装类在实际中用得最多的还在于字符串变为基本数据类型的操作上
  9. 小结
    1. JAVA中有八种基本数据类型的包装类，可以将基本数据类型以类的形式进行操作
    2. 基本数据类型变为包装类的过程，称为装箱，将包装类变为基本数据类型的过程，称为拆箱
    3. 在JDK1.5之后提供了自动装箱和自动拆箱的操作
    4. 实际上这八个类是JAVA中提供的类库，可以发现里面的宝座也是使用了所尝过的全部基本概念
    5. 使用包装类可以将字符串进行基本数据类型的转换

11.匿名内部类

  1. 内部类：在一个类的内部还有另外一个类称为内部类，那么匿名内部类，如果一个类在整个操作中只使用一次的话，就可以将其定义成匿名内部类，匿名内部类是在抽象类及接口的基础上发展起来的
  2. 小结
    1. 在实际的JAVA开发中经常会使用到各种开发的框架，在框架上会大量的引用匿名内部类
    2. 匿名内部类是在抽象类和接口的基础之上发展起来的
 

 

posted @ 2014-02-08 19:52  Leo.cheng  阅读(753)  评论(0)  编辑  收藏  举报