疯狂java讲义--笔记

第一章.Java语言概述与开发环境

什么是软件：一系列按照特定顺序组织的计算机数据和指令的集合；

交互方式：两种 GUI(Graphical User Interface) 图像界面 、CLI (Command Line Interface) 命令行方式

什么是计算机语言：人与计算机交流，如C、C++、java等

SUN(Stanford University Network 斯坦福大学网络公司)

 

发展过程：1990s sun公司 green计划（为智能家电编写通用控制系统）;

                C++缺少垃圾回收系统、可移植性、分布式和多线程等功能（最后决定自己研发一个新语言OAK）;

                1992s green操作系统，oak程序设计语言、类库;

                1994s 改造oak,完成第一个java语言的网页浏览器：WebRunner,由于OAK被人注册因此改为java;

                1995s sun公司发布了java语言 免费提供给大家使用(开源);

                applet java小程序

                1996s 需要有一个强大的开发类库，发布了JDK1.0（JRE运行环境和jdk开发环境）

                运行环境（JRE） ：核心API，集成API,用户界面API,发布技术,java虚拟机（JVM）五个部分组成；

                开发环境（JDK）：编译java程序的编译器（即javac命令）

                1997s  jdk1.1 增加JIT(即时编译)编译器

                1998s  jdk1.2 包含JSP/Servlet、EJB等规范，见java分成三个版本J2EE、J2SE和J2ME

                2002s  jdk1.4

                2004s  jdk1.5  改名Java SE 5.0、J2EE、Java EE、java ME  升级EJB3.0规范,推出MVC框架规范：JSF

                2006s  jdk1.6  Java SE6

                2009s  Oracle 收购sun公司获得java和solaris;

                2007s  google推出Android

                2011s  oracle 发布Java SE 7

                2014s  Java SE 8    

同时期，Microsoft 推出 .net平台 并发布C#语言         

 

java三种技术架构：

J2EE (java 2 platform Enterprise Edition) 企业版  包含技术servlet JSP,主要针对web应用程序开发；

J2SE (java 2 platform standard Edition) 标准版  开发普通桌面和商务应用程序；

J2ME (java 2 platform Micro Edition ) 小型版  电子消费产品及嵌入式设备提供解决方案；

Java 跨平台特性：因为有了JVM (java虚拟机用于解析)  java程序在三种操作系统(win/linux/mac)中都可执行，实现了java程序的跨平台性；

 

什么是JRE、JDK?

JRE(Java Runtime Environment) Java运行环境 包括虚拟机(jvm)和java核心类库 运行java程序只需按照JRE即可；

JDK(Java Development Kit) java开发工具包，包含了JRE，所以安装了JDK就不用安装JRE了；(包含javac编译工具和jar.exe打包工具)

JRE:JVM+JAVA Liabrary

JDK:JRE+Tools

 

编译型语言：C、C++、Objective-C、Pascal;

解释型语言：ruby、python、java

 

Java程序生成步骤：

Java虚拟机(JVM)负责执行字节码文件

 

垃圾回收机制（GarbageCollection,GC）JRE会提供一个后台线程来进行检测和控制，一般在CPU和内存不足时自动进行垃圾回收，而程序员无法精确控制垃圾回收的时间和顺序等；

特点：垃圾回收机制的工作目标是回收无用对象的内存空间，这些内存空间都是JVM堆内存里的内存空间，垃圾回收只能回收内存资源，对其他物理资源，如数据库连接、磁盘I/O等资源则无能为力；

为了更快地让垃圾回收机制回收那些不再使用的对象，可以将该对象的引用变量设置为NULL，通过这种方式暗示垃圾回收机制可以回收该对象；

 

ps:不要使用任何IDE工具来学习java编程；

 

question：

1.JAVA EE是什么规范？

A: J2EE中的13种核心技术规范：JDBC, JNDI, EJBs, RMI, JSP, Java servlets, XML, JMS, Java IDL, JTS, JTA, JavaMail 和 JAF。

   1) Servlet是一种小型的Java程序，它扩展了Web服务器的功能

 

2.applet 小程序

A: Java Applet 是用Java 语言编写的一些小应用程序，这些程序是直接嵌入到页面中，由支持Java的浏览器(IE 或 Netscape)解释执行能够产生特殊效果的程序, 包含Applet的网页被称为Java-powered页，可以称其为Java支持的网页。 Applet 小应用程序的实现主要依靠java.applet包中的Applet类, Applet 程序离不开使用它的HTML文件

 

3.javaScript

A: JavaScript一种直译式脚本语言，是一种动态类型、弱类型、基于原型的语言，内置支持类型。它的解释器被称为JavaScript引擎，为浏览器的一部分，广泛用于客户端的脚本语言，最早是在HTML（标准通用标记语言下的一个应用）网页上使用，用来给HTML网页增加动态功能。

 

4.脚本语言

A: 是为了缩短传统的编写-编译-链接-运行（edit-compile-link-run）过程而创建的计算机编程语言;

脚本语言(JavaScript，VBscript等)介于HTML和C,C++,Java,C#等编程语言之间。　HTML通常用于格式化和链接文本。而编程语言通常用于向机器发出一系列复杂的指令。

 

5.什么是解释型语言 什么是编译型语言

A:编译型语言写的程序执行之前，需要一个专门的编译过程，把程序编译成为机器语言的文件，比如exe文件，以后要运行的话就不用重新翻译了，直接使用编译的结果就行了（exe文件），因为翻译只做了一次，运行时不需要翻译，所以编译型语言的程序执行效率高，但也不能一概而论，部分解释型语言的解释器通过在运行时动态优化代码，甚至能够使解释型语言的性能超过编译型语言。

解释则不同，解释性语言的程序不需要编译，省了道工序，解释性语言在运行程序的时候才翻译，比如解释性basic语言，专门有一个解释器能够直接执行basic程序，每个语句都是执行的时候才翻译。这样解释性语言每执行一次就要翻译一次，效率比较低。解释是一句一句的翻译。

像C/C++、Pascal/Object Pascal（Delphi）等都是编译语言，而一些网页脚本、服务器脚本及辅助开发接口这样的对速度要求不高、对不同系统平台间的兼容性有一定要求的程序则通常使用解释性语言，如JavaScript、VBScript、Perl、Python、Ruby、MATLAB 等等。

6.开源框架（Struts、WebWork、Hibernate、Spring）

A: 框架（Framework）是整个或部分系统的可重用设计，表现为一组抽象构件及构件实例间交互的方法;另一种定义认为，框架是可被应用开发者定制的应用骨架。前者是从应用方面而后者是从目的方面给出的定义。 框架，即framework。其实就是某种应用的半成品，就是一组组件，供你选用完成你自己的系统。简单说就是使用别人搭好的舞台，你来做表演。而且，框架一般是成熟的，不断升级的软件。

 

框架的概念最早起源于Smalltalk环境，其中最著名的框架是Smalltalk 80的用户界面框架MVC(Model-View-Controller)。

 

Struts  通过采用JavaServlet/JSP技术，实现了基于Java EEWeb应用的MVC设计模式的应用框架，是MVC经典设计模式中的一个经典产品。

WebWork     WebWork是由OpenSymphony组织开发的，致力于组件化和代码重用的J2EE Web框架。

Hibernate  是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。

Spring  是一个开源框架，Spring是于2003 年兴起的一个轻量级的Java 开发框架，由Rod Johnson 在其著作Expert One-On-One J2EE Development and Design中阐述的部分理念和原型衍生而来。它是为了解决企业应用开发的复杂性而创建的。

 

7.JSP/Servlet 、EJB3.0规范,推出MVC框架规范：JSF

A: 一个servlet就是Java编程语言中的一个类，它被用来扩展服务器的性能，服务器上驻留着可以通过“请求-响应”编程模型来访问的应用程序。

 

Enterprise JavaBeans（EJB）是一个用于分布式业务应用的标准服务器端组件模式。 

Enterprise JavaBeans（EJB）定义了3种企业Bean，分别是会话Bean（Session Bean）、实体Bean（Entity Bean）和消息驱动Bean（Massage Driver Bean）。 

 

JavaServer Faces (JSF) 是一种用于构建Java Web 应用程序的标准框架（是Java Community Process 规定的JSR-127标准）。它提供了一种以组件为中心的用户界面（UI）构建方法，从而简化了Java服务器端应用程序的开发。

 

8. .net 平台、 c#、ruby、Python

A: .NET是 Microsoft XML Web services 平台。XML Web services 允许应用程序通过 Internet 进行通讯和共享数据，而不管所采用的是哪种操作系统、设备或编程语言。Microsoft .NET 平台提供创建 XML Web services 并将这些服务集成在一起之所需。对个人用户的好处是无缝的、吸引人的体验。

.NET就是微软用来实现XML，Web Services，SOA（面向服务的体系结构service-oriented architecture）和敏捷性的技术。

 

C#是微软公司发布的一种面向对象的、运行于.NET Framework之上的高级程序设计语言。并定于在微软职业开发者论坛(PDC)上登台亮相。C#是微软公司研究员Anders Hejlsberg的最新成果。C#看起来与Java有着惊人的相似；它包括了诸如单一继承、接口、与Java几乎同样的语法和编译成中间代码再运行的过程。但是C#与Java有着明显的不同，它借鉴了Delphi的一个特点，与COM（组件对象模型）是直接集成的，而且它是微软公司 .NET windows网络框架的主角。

 

Ruby，一种为简单快捷的面向对象编程（面向对象程序设计）而创的脚本语言，在20世纪90年代由日本人松本行弘(Yukihiro Matsumoto)开发，遵守GPL协议和Ruby License。它的灵感与特性来自于 Perl、Smalltalk、Eiffel、Ada以及 Lisp 语言。

 

Python（英语发音：/ˈpaɪθən/）, 是一种面向对象、解释型计算机程序设计语言，由Guido van Rossum于1989年发明，第一个公开发行版发行于1991年。

 

9.垃圾回收机制和堆内存及栈内存；

A: 堆：存放类类型，用new建立，垃圾自动回收机制负责回收，速度慢

    栈：存放基本数据类型，速度快

 

10.设计模式；

A:设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。

设计模式分为三种类型，共23种。

创建型模式：单例模式、抽象工厂模式、建造者模式、工厂模式、原型模式。

结构型模式：适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式。

行为型模式：模版方法模式、命令模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式（Interpreter模式）、状态模式、策略模式、职责链模式、访问者模式。

 

 

第二章

1.面向对象三种基本特征：继承(Inheritance)、封装(Encapsulation)和多态(Ploymorphism)；

2.java程序最小单位是类；

3.面向对象方式是由OOA(面向对象分析)、OOD(面向对象设计)、OOP(面向对象编程)三个部分有机组成；

4.OOA和OOD结构需要使用一种方式来描述并记录，业界统一采用UML(统一建模语言)；

5.目前主流开发方法：结构化开发方法和面向对象开发方法（可重用性、可扩展性、可维护性）；

6.任何复杂的算法都可以由顺序结构、选择结构和循环结构（当型和直型循环）三种基本结构组合而成；

（选择结构：单选择结构，双选择结构，多选择结构）

7.面向对象的软件系统由多个类组成，类代表客观世界中具有某种特征的一类事物；

8.成员变量(状态数据)+方法(行为)=类定义

9.面向对象的程序单位是类，而面向过程的程序单位是函数(相当于方法)，因此面向对象比面向过程更简单、易用

10.封装是指将对象的实现细节隐藏起来，然后通过一些公用方法来暴露该对象的功能；

11.继承是面向对象实现软件复用的重要手段，当子类继承父类之后，子类作为一种特殊的父类，将直接获得父类的属性和方法；

12.多态指的是子类对象可以直接赋给父类变量,但运行时依然表现出子类的行为特征，意味着同一个类型的对象在执行同一个方法时，

可能表现出多种行为特征；

13.抽象就是忽略一个主题中与当前目标无关的那些方面，并不打算了解全部问题，而只是考虑部分问题。

例如person对象，不可能把person 的所有细节都定义出来，通常只能定义person的部分数据、行为特征;

14.对象的基本特点：标识的唯一性、分类性、多态性、封装性、模块独立性；

15.类:具有共同属性、共同方法的一类事物。关系：类是对象的抽象；对象则是类的实例；

16.对象间相互合作需要一个机制协助进行，这种机制称做消息；

17.类之间共享属性和操作的机制称为继承；

18.UML(统一建模语言)用例图、类图、组件图、部署图、顺序图、活动图、状态机图

19.使用class关键字定义类，使用extends关键字表示继承关系；

20.父类也可被称为大类，子类也可被称为小类；

21.开发者定义了JAVA类之后，可以使用new关键字来创建指定类的对象;

 

question：

1.UML

Unified Modeling Language 统计建模语言

 

 

第三章 数据类型和运算符

1.强类型语言：所有变量必须先声明、后使用；指定类型的变量只能接受类型与之匹配的值；（优点：编译过程能发现源代码是否错误）

2.JAVA语言有三种注释：单行注释、多行注释、文档注释；

//单行注释

 

/*多行注释1

  多行注释2*/

 

/**文档注释，会被提取到API文档中 */

 

3.API文档 成员变量(fields)、构造器、方法；

4.javadoc命令：javadoc 选项 java源文件|包

 

5.分隔符：（;、 { }、 [ ]、 ( )、空格、.）；

6.java可以跨越多行书写，但是一个字符串、变量名不能跨越多行；

7.花括号{}的作用是定义一个代码块；

8.方括号[]的作用是用于访问数组元素；

9.圆点.通常作类/对象和它的成员(成员变量、方法、和内部类)；

 

10.标识符以字母、下划线、$（美元符）开头，但是不能以数字开头 ；java是区分大小写的，并支持Unicode6.2.0字符集

 

11.强类型：1）所有变量需要先声明才能使用；

                 2）指定类型的变量只能接受类型与之相匹配的值；

声明变量：type varName[=初始值]； 如：int  a=1;(true、false、null不是关键字)

 

12.编程的本质就是对内存中数据的访问和修改； 通俗来说就是:变量相当于一个有名称的容器，该容器用于装各种不同的类型的数据；

    

13.两种类型：基本类型(Primitive Type)和引用类型(Reference Type)；

14.基本类型分为两大类：Boolean类型和数值类型;而数值类型分为整数类型和浮点类型；

    

                                             { 整数类型（byte 1,short 2 ,int 4 ,long 8)

                                             { 数值型:  {浮点类型 （float 4 ,  double 8 ）

                                             {          

                   {基本数据类型：   { 字符型：char 2 （char相当于无符号整数类型）

                   {                         {------------以上数值类型,数值表示字节-------------

                   {                         {布尔型：Boolean (true,false)

   数据类型：{

                   {                       {类 class

                   {引用数据类型：{接口 interface

                                           {数组 [ ]

                                           {特殊类型：null

 

byte:1个字节，在内存中占8位 表示范围：-128至127 （-2^7 至2^7-1）

short:2个字节，在内存中占16位 表示范围：-32768至32767（-2^15 至2^15-1 ）

int:4个字节，在内存中占32位 表示范围：-2147483648至2147483647（-2^31 至2^31-1 ）

char  表示范围: 0  至 65535

long:8个字节，在内存中占64位 表示范围：（-2^63 至2^63-1 ） -9223372036854775808 至9223372036854775807

 

float 型数值，第一位是符号位，接下来8位表示指数，再接下来的23位表示尾数；（4字节 32位）

double 类型数值，第一位也是符号位，接下来11位表示指数，在接下52位表示尾数；（8字节 64位）

 

浮点数两种表示法：

 

十进制：5.12、512.0、.512

科学计数法:512e2或 512E2(即5.12*10^2) 

只有浮点数才可以使用科学计数法形式表示；

浮点类型默认double类型（占64位），如果要转换成float类型处理，应该在浮点类型（float占32位）值后面加“ f ”或者“F” 后缀，而”d“ 和”D“ 则是转换成double类型；

 

 

 

15.如果使用一个巨大的整数值(超出int类型的范围)，java不会自动把这个整数值当成long类型来处理；

应该在整数值后面增加l或L，由于英文字母l与数字1容易搞混，所以推荐用L

字符型必须使用单引号 ' ' 括起来; 区别：char类型使用单引号括起来，而字符串使用双引号括起来；

 

16.java的绝对路径如果写成：“c:\codes” 是得不到期望的结果，在java里面反斜杠是转义字符，所以应该写成“c:\\codes”;

 

17.对于数值位数特别多时,可以在数值中使用下画线，不管整数型数值还是浮点型数值;

boolean类型的值或变量主要用做旗标来进行流程控制：几种控制语句

 

三目运算符：（？：）

 

不同的基本类型的值可以互相转换，有两种方式：自动类型转换和强制类型转换；

ps:byte类型不能自动转换成char类型，但可以转换成double类型

 

强制类型转换的运算符是圆括号（()）

缩小转换将会引起溢出，从而造成数据丢失；

 

注意：float a = 5.6 这个赋值会出错；因为5.6默认是double类型，应改为 float a =（float ）5.6

 

表达式类型的自动提升：算术表达式的数据类型自动提升与表达式中最高等级操作数同样类型;

 

如：byte a = 40;

      char b = 'a';  //a ascii码等于97

      int    c = 23;

      double d = .314

  //因为右边运算时，表达式最高等级操作数为d(double类型)；

      double  result = a+b+c*d

  //结果：144.222 （40+97+23*0.314）

    System.out.println(result);

 

直接量：只有基本类型、字符串型和null类型能指定直接量；

 int a =5;

 char c='a';

 boolean d = true;

 float f =3.14f;

 double d = 3.14;

 String author ="david";

 

 常量池（constant pool）

 

 运算符：

 算术运算符 ：（加、减、乘、除、和求余）+:”+“除了能做加法运算，还能作为字符串的连接运算符；

 -：减法运算符；*：乘法运算符；/:除法运算符，当两个操作数都是整数类型时，则计算的结果也只会保留整数部分【截断取整】，还有就是被除数不能为零（by zero）；当然，两个操作数是浮点数时，结果也是浮点数，但是被除数可以是0.0 ，不会出异常报错提示，结果则会是正无穷大或负无穷大；

%:求余运算符，两个操作数相除剩下的值就是余数；第二个操作数也不能是0；如一个或两个操作数类型是浮点类型，则可以除以0或者0.0，不会引发除以零异常，只是结果显示：NaN(非数)；

 赋值运算符：为变量指定变量值，与C类似，使用”=“作为赋值运算符，左边是变量，右边是值；

 例：

     int a;

     int b;

     int c;

     a = b = c = 7; //三个变量都是7；（代码可读性低，不提倡此种写法）

 

 比较运算符：用于判断两个常量或者变量的大小，结果是一个布尔值（true或flase）

                    符号如下：> 大于, >=大于等于, <小于, <=小于等于, == 等于,!= 不等于;

 (注意：基本类型的变量、值不能与引用类型的变量、值使用==进行比较)

 

 逻辑运算符：&&(与),&（不短路与），||(或),|（不短路或）,!（非）,^（异或），用于操作两个布尔值的变量或常量;

 

 位运算符：一共七种：&（按位与）、|（按位或）、~（按位非）、^（按位异或）、

                 <<（左移运算符）、>>（右移运算符）、>>>（无符号右移运算符）

 

 类型相关运算符：

 三目运算符语法格式：

 (expression) ? if-true-statement ：if-flase-statement;

 

18.++：自加,单目运算符,只能操作一个操作数；自加运算符只能操作单个数值型的变量，不能操作常量或表达式

放在左边先把操作数加1，然后再放到表达式中运算，放在右边则把操作数先放到表达式才把操作数加1；

如：eg1:

      int a = 5;

      int b = a++ + 6 //结果：a=6,b=11; "++"在操作数的右边，因此先是a+6(此时a = 5),然后才对a+1

     

      eg2:

      int a =5

      int b = ++a + 6 //结果：a=6,b=12; "++"在操作数的左边，因此先是a自身+1(此时a = 6),然后再执行a+6运算（此时a=6）

 

19.--自减，与自加相似，操作数减1（与自加一样适用于变量，不能用于直接量、常量、表达式；如：5++，6-- 写法是错误的）

 

20.复杂的运算要借助java.lang.Math类工具

如:Math.pow(a,b)  //求a的b次方；

     Math.sqrt(a)  //求a的平方根;

     Math.Random //计算随机数；

     Math.sin(a) //计算a的sin 函数值；

 

21.运算符优先级

 

question：

1.熟悉使用javadoc工具2.ASCII字符集、Unicode字符集

3.editplus工具使用

4.补码、反码、原码？

5.溢出

6.三目运算符

 

 

第四章 流程控制与数组

 

1.两种基本流程控制结构：分支结构和循环结构；

2.分支结构（if,switch）循环结构（while,do while,for） [foreach,break,continue]

3.if使用布尔表达式或布尔值作为分支条件，而switch语句则用于多个整型值进行匹配；

4.在使用if...else语句时有一条基本规则:总是优先把包含范围小的条件放在前面处理；

5.switch语句控制表达式的数据类型只能是byte,short,char,int四种整数类型，枚举类型和java.lang.String类型(JAVA7才支持)，不能是boolean类型；

6.循环语句四部分：初始化语句(init_statement)、循环条件(test_expresstion)、循环体(body_statement)、迭代语句(ireration_statement);

7.while语句的循环条件后面紧跟一个分号，这个是错误的,将会导致后面的语句与循环没任何关系了；

8.do while与while语句区别：while 先判断条件为true再执行；do while则先执行循环体，再判断条件，直到为true；（do while循环的循环体至少要执行一次）

9.for循环语法结构：for ([init_statement,init_statement 1,init_statement 2,......],[test_expression],[iteration_statement])

                             {

                                  statement

                              }

  可以包含多个初始化语句以及循环条件

 

10.java提供了continue和break来控制循环御语句；（return可以结束整个方法及一次循环）

11.continue 只忽略本次循环剩下的语句，接着开始下一个循环，而break则完全终止循环；

12.outer: 外层循环的使用；

13.定义数组：type[ ] arrayName;  type arrayName [ ];

14.int 是基本类型，而int [ ] 是引用类型；

15.数组是一种引用类型的变量(指针);

16.数组要初始化，初始化即为数组的元素分配内存空间，并赋初始值；

17.静态初始化：arrayName=new type [] {element1,element2,element3......};

                        type[] arrayName = {element1,element2,element3......};

18.动态初始化：只指定数组的长度；

                       arrayName= new type[length];

19.不要同时使用静态初始化和动态初始化；

20.异常提示：java.lang.ArrayIndexOutOfBoundsException:N (数组索引越界异常) 指定的索引值小于0，或者大于等于数组的长度；

21.foreach循环

 

 

question：

1.嵌套循环

2.乘法表

3.打印圆形图案

4.小写转大写的程序（如1,2,3,4,5 显示壹，贰，叁，肆，伍）

5.控制台五子棋游戏

 

 

第五章 面向对象（上）

1.public、private、protected 三个访问控制修饰符实现封装;

2.extends关键字让子类继承父类;

3.面向对象两个重要概念：类（class）和对象（object）也称实例（instance）;

4.定义类的格式：

 【修饰符】calss  类名称

{

     零个到多个构造器定义..

     零个到多个成员变量..

     零个到多个方法.. 

}

【修饰符】：public、final、abstract

5.一个类定义，包含三种最常见的成员：构造器、成员变量和方法；java类的作用：定义变量；创建对象；调用类的类方法或访问类的类的类变量。

6.java使用关键字new 来调用构造器，从而返回该类实例；

7.定义成员变量语法格式：

 【修饰符】 类型 成员变量名 【= 默认值】

修饰符可以省略，也可以是：public、protected、private、static、final,其中public、protected、private三个最多只能出现其中之一；

8.static修饰的成员变量和方法称为静态变量和静态方法；

9.创建对象的根本途径是构造器;

eg:

   Person p

        p = new Person();

或 Person p = new Person();

10.对象、引用、和指针；

栈内存里的引用变量并未真正存储对象的成员变量，对象的成员变量数据实际存放在堆内存里；

引用变量里存放的仅仅是一个引用，它指向实际的对象；

引用变量与C语言中的指针很像，他们都是存储一个地址值，通过这个地址来引用到实际对象；

11.this关键字 指向调用该方法的对象,this可以代表任何对象，谁调用此方法，this就代表谁；

12.static修饰的方法中不能使用this引用；

13.JAVA编程不要用对象去调用static修饰的成员变量及方法，而是应该使用类去调用static修饰的成员变量及方法

14.方法是类或对象的行为特征的抽象；方法在逻辑上要么属于类，要么属于对象；(从功能上来看，方法完全类似于传统结构化程序设计里的函数)

15.java语言方法的所属性体现：方法不能独立定义，方法只能在类体里定义；

                                             从逻辑意义上来看，方法要么属于该类本身，要么属于该类的一个对象；

                                             永远不能独立执行方法，执行方法必须使用类或者对象作为调用者；

16.方法的参数传递机制：值传递的实质，当系统开始执行方法时，系统为形参执行初始化，就是把实参变量的值赋给方法的形参变量，方法里操作

的并不是实际的实参变量；

17.递归方法：一个方法体内调用它自身，被称为方法递归；递归一定要向已知方向递归。

18.方法的重载：同一个类中包含两个或者两个以上方法的方法名相同，但形参列表不同，则被称为方法重载；

19.成员变量与局部变量

成员变量指的是类里定义的变量，也就是前面说介绍的field;没有static修饰的是实例变量，有static修饰的就是类变量;

局部变量指的是在方法里定义的变量；

20.形参的作用域是整个方法体内有效，而且形参也无须显式初始化，形参的初始化在调用该方法时由系统完成，形参的值由方法的调用者负责；

21.局部变量定义后，必须经过显式初始化后才能使用，系统不会为局部变量执行初始化；（程序给变量赋初始化值时，系统才会为变量分配内存）；

22.栈内存中的变量无需系统垃圾回收，往往随着方法或者代码块的运行结束而结束；

23.因为局部变量只保存基本类型的值或者对象的引用，因此局部变量所占的内存区通常比较小；

24.变量的使用规则：对于一个循环变量而言，只需要它在循环体内有效，因此只需把这个变量放在循环体内（代码块内定义）

局部变量的作用范围越小，它在内存里停留的时间就越短，程序运行性能就越好；

25.封装：对象的状态信息都被隐藏在对象内部，外界无法直接操作和修改；（通过访问控制符来控制）

26.访问控制符（private、protected、public）访问权限从小到大private--->default(默认)--->protected---->public

27.private 当前类访问权限（用于修饰成员变量最合适）

    default 包访问权限，不使用任何访问控制修饰符时；

    protected 子类访问权限，可以被同一个包中的其他类访问，也可以被不同包中的子类访问；

    public 公共访问权限，这是一个最宽松的访问控制级别

28.如果一个java源文件里定义的所有类都没有使用public修饰，则这个java源文件的文件名可以是一切合法的文件名；但如果一个java源文件里定义了一个public修饰的类，则这个源文件的文件名必须与public修饰的类的类型相同；

29.包：java引入包（package）机制，提供了类的多层命名空间，用于解决类的命名冲突、类文件管理等； 

    编译包命令：javac -d . [name].java 

    package语句必须作为源文件的第一条非注释性语句，一个源文件只能指定一个包，即只能包含一条package语句，该源文件中可以定义多个类，

    则这些类将全部位于该包下；（同一个包下的类可以自由访问）

30.

java包机制需要两个方面的保证：1)源文件里使用package语句指定包名；2）class文件必须放在对应的路径下。

 

31.import关键字，import语句出现在package语句之后、类定义之前；一个类只能包含一个package语句，但可以包含多个import语句；

格式：import lee.* 导入lee包下所有类；

32.java默认所有源文件导入java.lang包下的所有类，因此前面在java程序中使用string等类时无需使用import语句来导入这些类；

33. 静态导入使用import static语句，使用import可以省略写包名；而使用import static则可以连类名都省略；

JAVA源文件结构：

34.构造器是一个特殊的方法，这个特殊方法用于创建实例时执行初始化；

35.类的继承：java继承通过extends关键字来实现，实现继承的类被称为子类，被继承的类被称为父类（基类、超类）

   格式：修饰符 class SubClass extends SuperClass  {//类定义部分}

36.java.lang.Object类是所有类的父类，要么是其直接父类，要么是其间接父类；  （继承，扩展，派生说描述的是同一个动作）

37.方法重写（Override）,也称为方法覆盖；方法重写（Override）和方法重载（Overload）

38.super用于限定该对象调用它从父类继承得到的实例变量或方法；（作用：访问父类中定义的、被隐藏的实例变量，或为了在子类方法中调用父类中定义

的、被覆盖的方法）

39.在一个构造器中调用另一个重载的构造器使用this调用来完成，在子类构造器中调用父类构造器使用super调用来完成；

40.创建任何java对象，最先执行的总是java.lang.Object类的构造器；

41.多态：java引用变量有两个类型：一个是编译时类型，一个是运行时类型；

42.类型转换运算符：(type)variable,将variable变量转换成一个type类型变量；（在进行强行转换类型之前，先用instanceof运算符判断是否可以成功转换，从而避免出现ClassCastException异常）

43.instanceof和（type）是java提供的两个相关的运算符，通常先用instanceof判断一个对象是否可以强制类型转换，然后再使用（type）运算符进行强制类型转换；

44.继承是实现类复用的重要手段，但继承的坏处就是破坏封装；（而采用组合方式来实现类复用则能提供更好的封装性）

45.初始化块是java类里可出现的第四种成员（成员变量，方法和构造器）初始化块的修饰符只能是static,使用static修饰的初始化块被称为静态初始化块；

 

question：

1.构造器是什么？

2.栈内存与堆内存的区别？

3.类，对象，实例，成员变量，方法，函数？

4.递归，历遍？

5.显式，隐式？

6.dao包？

7.继承与组合区别？

8.修饰符public、protected、private、static、final、abstract

9.this关键字

10.指针？ 引用类型？

11.JAVA源文件结构？

 

待续。。。。。。。。。。。。。。。。。。。。