随笔 - 19  文章 - 0  trackbacks - 0
<2012年8月>
2930311234
567891011
12131415161718
19202122232425
2627282930311
2345678

常用链接

留言簿

随笔档案

搜索

  •  

最新评论

阅读排行榜

评论排行榜

     摘要: AM上午总结: 1 package com.java.kudy.day17_2.ObjectReview; 2 3 public class ObjectTest { 4 5 /** 6 *虚拟机做了什么事情? 7 *1.在栈内存中定义了一个变量p 8 *2.在类加载器中加载Person.class 9 *...  阅读全文
posted @ 2012-08-19 18:54 、小细 阅读(136) | 评论 (0)编辑 收藏

所有的流在使用完毕时,都需要调用close方法进行关流,释放资源。
由于流操作都会有异常,如果发生异常就有可能导致close方法不能被调用
所以,IO异常一定要处理,close方法写在finally语句中
1.InputStream : 输入字节流 方法: read()从流(关联的设备)中读一个字节
** int read(buf):从流中读取n个字节放入缓冲区,方法会返回一个读取字节的个数 ips-->buf
读到一个-1,说明读到了流的末尾
 ------------------------------------------------------------------------------------------
|---FileInputStream: 重载的构造函数  (String fileName)  (File file)

2.OutputStream: 输出字节流 :方法 write(int c)将一个字节写入流  (byte)c
write(buf,offset,len)将指定字节数组的一部分写入流。 buf-->ops
 -------------------------------------------------------------------------------------------
|---FileOutputStream: 重载的构造函数 (Strng fileName) (String fileName, boolean append)
 append:指定数据是否追加到文件的末尾,默认是false,覆盖原有的数据,
 设置为true,将数据追加到文件的末尾
3.Reader:输入字符流 int read() 读一个字符   int read(buf)  buf是char[]类型
|---FileReader:  FileReader = InputStreamReader(FileInputStream) 只做了一件事:解码(父类在做)
4.Writer:输出字符流 write(int c) (char)c \  write(String str)
|---|---FileWriter:  FileWriter = OutputStreamWriter(FileOutputStream) 只做了一件事:编码

理解(会用):
1.装饰设计模式: 对原有的类的进行包装,对方法进行增强
BufferedReader:实现缓冲的功能   创建包装流对象的时候,必须组合一个被包装的底层流
    增加了一个新方法 String readLine() 读一行
|--LineNumberReader: 增加了行号功能,getLineNumber() 、setLineNumber()
BufferedWriter:实现了缓冲功能  new BufferedWriter(new FileWriter("1.txt");
    增加了新方法  newLine() 另起一行
BufferedInputStream:实现缓冲的功能
BufferedOutputStream:实现缓冲的功能

2.InputStreamReader: 转换流   : 包装,实现了编码解码的功能
new InputStreamReader(new FileInputStream("1.txt"));

3.使用包装流包装System.in,读键盘方便,可以读一行
BufferedReader br =
 new BufferedReader(new InputStreamReader(System.in));
String line = br.readLine();
 
 
IO需要会写的程序: BufferedReader和BufferedWriter包装InputStream和OutputStream,读一行写一行

  BufferedReader和BufferedWriter包装Reader和Writer
  BufferedInputStream和BufferedOutputStream包装InputStream和OutputStream
  用基础流读写,自定义数组作为缓冲区,实现拷贝
  
-------以下做一个总结:

io流:数据传输的中转站-->IO流-->目的地

 IO流一般都是成对出现的,也就是说按照流的分向:输入流-->输出流
 IO流按照操作来分: 字节流-->字符流
 
一.字符流
基类:Reader(读)Writer(写)
|-Reader
 |--BufferedReader:对Reader进行了包装,提供了缓冲区(8192),有ReadLine()方法
  构造函数:BufferedReader(Reader r);
 |--InputStreamReader:转换流:将字节流转换成字符流:new InputStreamReader(System.in);
  |--FileReader:读取文件的字符流,FileReader(File file) FileReader(String fileName);
|-Writer
 |--BufferedWriter:包装流:常用的方法write(String s)、flush()刷新  newLine()换行
  构造函数:BufferedWriter(Writer w);
 |--OutputStreamWriter:转换流: new OutputStreamWriter(System.out);
  |--FileWriter:写入文件,FileWriter(File file)  FileWriter(String fileName)
   FileWriter(File file,boolean append),FileWriter(String fileName,boolean append)
   当append为true,将写入到文件的末尾处,当为false时,从文件开头开始写.就会覆盖原来的.默认为false
   
二.字节流:
|-InputStream(输入流)
 |--FileInputStream:读取文件的字符流,和FileReader基本是一样
 |--FilterInputStream:过滤流,一般不使用,只是针对了InputStream进行了包装
  |--BufferedInputStream:包装类:BufferedReader(InputStream in),提供缓存功能
  
|-OutputStream(输出流)
 |--FileOutputStream:写入文件的字符流,和FileWriter基本一样
 |--FilterOutputStream
  |--BufferedOutputStream:包装类:BufferedWriter(OutputStream out);
  
三.使用IO流必须要捕获异常,原因在于我们必须要还资源(关闭流)

 1 FileWriter fw = null;
 2 try
 3 {
 4     fw = new FileWriter("src/1.txt");
 5 }
 6 catch(IOException e)
 7 {
 8     e.printStractTrace();
 9 }
10 finally
11 {
12     try{if(fw!=null)fw.close();}catch(IOException){e.printStackTrace();}
13 }

四.File文件类
1.构造方法:
File(File parnt,String child)
根据prent抽象路径名和child路径名字符串创建一个新的file实例.
File(String pathname)
通过将给定的路径名字来创建一个新的file实例.
File(String parent, String child)
根据 parent 路径名字符串和 child 路径名字符串创建一个新 File 实例.

2.常用方法:
isFile:判断对象是否是一个标准文件
isDirectory:判断对象是否为一个文件夹
isAbsolute:判断是否为一个绝对路径
exists:判断对象指定的文件是否存在
createNewFile:根据对象的描述创建一个对象
getName:获得文件名
getPath:获得路径名
getParent:获得文件的父级抽象路径
getAbsolutepath:获得文件的绝对路径名
mkdir:创建此抽象路径指定的目录,(只能在存在的文件夹下创建一个目录)
mkdirs:创建此抽象路径指定的目录,包括所有必须但不存在的目录.创建多级目录(c:/a/b/c)
list(FilenameFilter filter):根据指定过滤器遍历文件夹中的所有文件,返回String[]
 如果对象为标准文件,则返回null,如果对象是一个空文件夹,则返回空数组。length为0
 FilenameFilter是一个接口,只有一个方法accept,我们需要实现接口的accept方法。
 实现类是给list方法自动调用的
 方法的参数是list方法传给我们的,返回的结果也是给list方法去用。
listFiles:和list基本一样,返回值类型不一样,返回File[]。
常用案例:遍历目录下所有的文件和文件夹   拷贝一个文件夹  .

五:RandomAccessFile 文件流,可以读写
1.RandomAccessFile(File file,String mode)、RandomAccessFile(String fileName,String mode)
 mode:常用的: r,只读 rw读写
2.有很多read和write方法.
 seek方法,指定从那个位置开始读seek(0) ,从原有的位置覆盖掉
skipBytes(int n):跳过多少个字节

六:PrintStream、PrintWriter打印流
有一个特殊的方法print可以实现打印
write方法是直接将字节和字符写出去
print:首先调用对象的toString方法转成字符串(如果是基本数据类型,会先自动装箱)
 再将字符串编码成字节数组,调用write方法写出去

七:SequenceInputStream序列流
可以将多个字节流组合起来
构造方法:SequenceInputStream(Enumeration<? extends InputStream> e) 
  //Enumeration可以通过Vector来获得,如果用的是ArrayList,如何获得呢?
     SequenceInputStream(InputStream in1,InputStream in2)

八:ObjectInputStream、ObjectOutputStream操作对象的字节流
一般成对出现
使用writeObject方法写入的对象,只能由readObject方法读出来
操作的对象必须实现java.io.Serializable序列化接口,该对象才可以被序列化和反序列化。
序列化: Java中规定的一种保存对象的数据格式

九:DataInputStream、DataOutputStream操作基本数据类型,格式化数据
readInt、writeInt等方法。
writeInt写入一个整数,文件大小为4字节。证明就是把基本数据类型对应的字节写出去了,没有丢失精度

十:ByteArrayInputStream、ByteArrayOutputStream对Byte数组进行读写的字节流,针对内存进行读写
源和目的地都是内存,一般用于对内存中的数据进行处理。

十一:PipedInputStream、PipedOutputStream管道流
1、输入管道流
构造方法:PipedInputStream(PipedOutputStream pos)实现拼接
也可以通过connect(PipedOutputStream pos)方法进行拼接

2、输出管道流
构造方法:PipedOutputStream(PipedInputStream pis)实现拼接
也可以通过connect(PipedInputStream pis)方法进行拼接

 1 --Test:序列化与反序列化..
 2 package com.java.kudy_Say;
 3 
 4 import java.io.FileNotFoundException;
 5 import java.io.FileOutputStream;
 6 import java.io.IOException;
 7 import java.io.ObjectOutputStream;
 8 import java.io.Serializable;
 9 import java.util.ArrayList;
10 import java.io.ObjectInputStream;
11 import java.io.FileInputStream;
12 /*
13     序列化与反序列化的过程
14 */
15 public class Test {
16     
17     public static void main(String[]args) throws FileNotFoundException, IOException,ClassNotFoundException
18     {
19             
20 /*        Student s1 = new Student("张三",18);
21         Student s2 = new Student("王五",19);
22         Student s3 = new Student("李四",20);
23         Student s4 = new Student("大毛",21);
24         ObjectOutputStream oos = 
25                 new ObjectOutputStream(new FileOutputStream("f:/a.txt"));
26         ArrayList<Student> al = new ArrayList<Student>();
27         al.add(s1);
28         al.add(s2);
29         al.add(s3);
30         al.add(s4);
31         oos.writeObject(al);
32         oos.close();//关闭流
33         //首先我们把内容放到一个集合里面去
34 */
35         ObjectInputStream ois = 
36                 new ObjectInputStream(new FileInputStream("f:/a.txt"));
37         ArrayList<Student> al = (ArrayList<Student>)ois.readObject();
38         for(Student s :al)
39             System.out.println(s);
40         ois.close();
41     
42     
43         
44     }
45 }
46 
47 //必须要实现一个类
48 class Student implements Serializable
49 {
50     private String name;
51     private int age;
52     Student(){}
53     Student(String name,int age)
54     {
55         this.name = name;
56         this.age = age;
57     }
58     public String toString()
59     {
60         return name+"@"+age;
61     }
62 }

 

posted @ 2012-08-18 19:51 、小细 阅读(251) | 评论 (0)编辑 收藏

教程由JAVA中文网整理校对发布(javaweb.cc)

     Abstract Window Toolkit(AWT)抽象窗口工具集
  一个用本地图形组件实现的图形接口。这些组件提供了大部分的本地组件。这个接口正逐步被Swing组件所替代,参见Swing Set.

  Abstract 抽象的
  一个Java语言中的关键字,用在类的声明中来指明一个类是不能被实例化的,但是可以被其它类继承。一个抽象类可以使用抽象方法,抽象方法不需要实现,但是需要在子类中被实现

  abstract class 抽象类
  含有一个或多个抽象方法的类,不能被实例化。定义抽象类的目的是使其他类能够从它继承,并且通过实现抽象方法使这个类具体化

  abstract method 抽象方法
  没有实现的方法

  access control 访问控制
  控制用户或程序访问资源的权限,保证资源的一致性的方法

  API 应用程序接口
  Application Programming Interface的缩写。指导应用程序开发人员访问类方法和类状态的说明

  applet 小应用程序
  通常在Web浏览器中执行的一个Java组件,同样可以在其他的支持applet模型的应用程序或设备中执行
 
  Applet container applet容器
  一个支持applet的容器

  argument 参数
  在函数调用中使用的数据项。一个参数可以是常量、变量或表达式
 
  array 数组
  相同类型的数据的集合,每一个数据项通过一个整数唯一标识

  ASCII
  American Standard Code for Information Interchange的缩写。一个标准的7位字符编码,参见Unicode

 

       Bean
  一个可以重用的组件,可以通过组合Bean来创建应用程序

  bean-managed persistence
  当一个实体bean实例和资源管理器交换数据的时候,由实体bean实例来管理

  bean-managed transaction
  Enterprise Bean定义事务的界限的时候

  binary operator 二值操作符
  有两个操作数的操作符

  bit 位
  计算机中表示信息的最小单位,只有0和1两个值

  bitwise operator 位操作符
  并行的对一个或多个操作数的位进行单独的操作。比如二进制逻辑运算符(&,|,^),二进制移位符(<<,>>,>>>)和求补运算符(~)

  block 块
  在Java语言中,任何被大括号括起来的程序段。

  boolean 逻辑型
  指一个表达式或一个变量只能有true或者false两种类型。Java语言提供了boolean类型以及true和false两个常量

  break
  一个Java的关键字,用来改变程序执行流程,立刻从当前语句的下一句开始执行从。如果后面跟有一个标签,则从标签对应的地方开始执行

  business logic 商业逻辑
  实现某个应用功能的代码。在Enterprise JavaBeans模型中,这种逻辑是由某个Enterprise Javabean的方法实现的。

  business method 商业方法
  某个Enterprise Javabean的方法用来实现商业逻辑或者某个应用的规则。

  Byte 字节
  顺序的8位bit,Java语言中有对应的byte类型

  bytecode 字节码
  由Java编译器生成的跟机器相关代码,由Java解释器执行

  callback methods 回调方法
  组件的方法,由存放该组件的容器来调用的,用来在组件生命周期中通知它重要的事件

  case
  Java语言的关键字,用来定义一组分支选择,如果某个值和switch中给出的值一样,就会从该分支开始执行。

  casting
  强制类型转化换
 
  catch
  Java的一个关键字,用来声明当try语句块中发生运行时错误或非运行时异常时运行的一个块。

  char
  Java语言的一个关键字,用来定义一个字符类型

  class 类
  在Java语言中定义一个特定类的实现。一个类的定义包含成员变量,成员方法,还有这个类实现的接口,以及这个类的父类。如果没有显式指明父类,那么它的父类会隐式的被认为是Object。

  class method 类方法
  不需要引用特定对象就可以使用的方法,类方法的作用域是全局的,而不是某个特定的类实例,也被称作静态方法static method,参看instance method

  classpath 类路径
  Classpath是一个环境变量,用来向Java虚拟机和基于Java的应用程序指明系统类库和用户类库的位置(比如,工具包在JDK1.1.X/bin目录中)

  class variable 类变量
  一个和整个类相关的数据项,而不是只和某个实例,类变量在类定义中定义,也被称作static field,参看instance variable.

  codebase
  和<APPLET>标签中的Code属性配合给出找到applet类的完整路径:Code给出文件的名字,Codebase指出包含该文件的URL路径

  comment 注释
  在编程语言中被编译器忽略的解释性语句。在Java中注释使用//或/*…*/定界

  compiler 编译器
  一个把源代码翻译成机器可以执行的代码的程序。Java编译器把Java源码翻译成Java虚拟机能够识别的字节码,参见interpreter

  component 组件
  一种被容器所支持的应用级的软件单元。组件在使用的时候是可配置的。J2EE平台定义了四种类型的组件:Enterprise Bean,Web components,applets和application client。

  component contract
  组件和它的容器之间的规范。这种规范包括:组件的生命周期的管理,一个上下文的接口,组件可以通过它获得容器的信息和服务,以及每个容器必须提供的一系列服务。

  component environment
  应用程序组件提供商定义的一个集合,使组件在J2EE组件的名字空间中可见。环境选项由组件的使用描述符指明。每一个组件命名并访问它的环境配置值通过使用java:comp/evn JNDI上下文。这些值可以是组件所依赖的一个对象,比如JDBC DataSouce,或者一个简单值,比如一个税率。

  Connector 连接器
  一个标准的扩充机制使容器可以提供到EISs的连接。一个连接器连接到特定的EIS,由资源适配器和针对EIS的应用开发工具组成。一个资源适配器插入到一个容器通过在连接器体系结构中定义的系统级的联系。

  connector architecture
  一个集成J2EE和EISs的体系结构。这个体系结构中有两大部分:一个EIS厂商提供的资源适配器和一个允许这个适配器插入的J2EE服务器。这个体系结构定义了一系列资源适配器为了能插入J2EE服务器而必须支持的规范,比如事务,安全,资源管理。

  Constructor 构造函数
  一个创建对象的伪方法。在Java语言中构造函数是和类同名的成员函数。构造函数一般用在new操作符之后。

  Container 容器
  一个为组件提供生命周期管理,安全,配置,和运行时服务的实体。每一个类型的容器(EJB, Web, JSP, servlet, applet, 和application client)也会提供各自组件相关的服务

  container-managed persistence
  当一个实体bean实例和资源管理器交换数据的时候,由资源管理器来管理

  container-managed transaction
  当一个EJB容器定义一个事务的边界的时候,一个Bean必须使用这种事务类型

  continue
  一个Java的关键字,用来打断当前循环过程,从当前循环的最后重新开始执行,如果后面跟有一个标签,则从标签对应的地方开始执行。

  core class 核心类
  一个Java平台上的标准的公共类或接口。Java平台的核心类,至少在所有的能支持Java的操作系统的平台上都是可用的。一个完全用Java编写的程序只需要Java核心类就可以运行了,这意味着它能够在任何地方运行,参看100% Pure Java(TM).

  Core Packages 核心包
  在任何Java平台和任何兼容平台上必须被支持的API的集合。

  Declaration 声明
  一个在标识符和属性之间建立联系的语句,不需要必要的存储分配或具体实现。参见definition

  default 缺省的
  一个Java语言的关键字,作为在switch语句中的所有case之后的可选项,如果所有的case条件都没有被满足,就会执行default语句
 
  delegation 授权
  一种某个负责人批准另外一个负责人在一定限制下使用它的身份或特权的行为

  deprecation
  指不再推荐的类,接口,构造函数,方法或成员变量,可能在以后的版本中会消失

  derived from
  类X "derived from" 类Y就是指类X是从类Y继承过来的,参见subclass, superclass

  distributed 分布的
  在多于一个的地址空间内运行
  
  distributed application 分布式应用
  由不同的运行于分离的运行环境下的组件构成的应用程序,通常是在不同的平台上通过网络互联起来。典型的分布式应用是二端(Client/Server),三端(client/middleware/server)和n端(client/multiple middleware/multiple server)

  do
  一个Java语言的关键字,用来声明一个循环,这个循环的结束条件可以通过while关键字设置

  DOM
  Document Object Model的缩写。一棵由拥有包含遍历这棵树并且生成相应XML文档的接口的对象构成的树,符合W3C的规范

  double
  一个Java语言的关键字,用来定义一个double类型的变量

  EJB container EJB容器
  一个实现了J2EE体系结构中EJB组件规范的容器。这个规范指定了一个Enterprise bean的运行时环境,包括安全,一致性,生命周期,事务,配置,和其他的服务。一个EJB容器可以由EJB或者J2EE服务器提供。

  EJB Container Provider EJB容器提供商
  提供EJB容器的厂商

  EJB context EJB上下文
  一个允许Enterprise Bean使用容器提供的服务和获得客户-请求(client-invoke)方法调用者信息的对象

  EJB home object
  一个提供关于Enterprise Bean生命周期操作(创建,删除,查找)的对象。这个对象的类型是由容器的配置工具产生的。EJB home object实现了Enterpeise Bean的home接口。客户通过引用一个EJB home object来进行生命周期的操作。客户使用JNDI来定位一个EJB home object

  EJB .jar file
  一个包含EJB模块的JAR文件

  EJB module
  一个由一个或多个Enterprise bean和一个EJB配置描述符组成的软件单元。

  EJB object
  实现了enterprise bean的remote接口的对象。客户不能直接引用一个enterprise bean的实例;客户总是引用一个EJB object。EJB object的类型是由容器的配置工具生成的。

  EJB server
  为EJB容器提供服务的软件。比如,典型的,一个EJB容器总是依靠一个作为EJB Server一部分的事务管理器来进行双向的确认在所有参与的资源管理器之间。J2EE体系结构假设EJB容器和EJB Server是由同一厂商提供的,所以没有制定这两个实体之间的规范。一个EJB Server可以包含一个或多个EJB Container

  EJB Server Provider
  提供EJB Server的厂商

  EIS resource
  一个为客户提供符合EIS规范的功能的实体。例子有:一条或多条数据库中的记录,在一个ERP系统中的一个business object,在一个事务处理系统中的一个事务程序

  else
  一个Java语言的关键字,如果if语句的条件不满足就会执行该语句。

  encapsulation 封装
  一个模块中的内部属性,因为对象会封装数据和实现,使用者可以把对象看作一个能提供服务的黑匣子。实例变量可以被添加,删除,或改变。只要这个对象所提供的服务是不变的,使用这个对象的代码就可以继续使用而不需要修改,参见instance variable, instance method.

  enterprise bean
  实现商业任务和商业实体的组件;或者是一个entity bean,或者是一个session bean

  Enterprise Information System (EIS)
  一个包含企业已经存在的获取企业级信息的系统的应用程序,这些应用程序为企业提供了一个信息结构。一个EIS系统提供很好定义的服务的集合给它的客户。这些服务在客户看来是本地的和/或者远程的接口。EIS的例子有:一个ERP系统,一个事务处理系统的主框架,一个遗留的数据库系统。

  Enterprise Bean Provider Enterprise Bean提供商
  生产enterprise bean,remote和home接口,配置描述符文件,并把这些打包入JAR文件的应用程序开发人员

  Enterprise JavaBeans(TM) (EJB)
  一个用于开发和使用面向对象的,分布式的,企业级应用程序的组件体系结构。使用Enterprise JavaBeans体系结构编写的软件是可扩展的,面向事务的,多用户的,安全的。

  entity bean
  一个代表由数据库维护的持久数据的enterprise bean。一个entity bean可以管理它自己的持久性,或者把这个功能授权给它的容器。一个  entity bean由一个主键来标识。如果存放entity bean的容器崩溃了,那么这个entity bean,它的主键,以及任何远程的引用都能从崩溃中幸存下来。

  ebXML
  ebXML建立在XML(Extensive Markup Language)之上,目的是提供一系列模块化的规范,使任何地方的任何规模的企业都能够通过Internet指导商业活动。它提供了公司和组织一个标准的方法来交换数据,指导商业关系,交流数据通过公共的形式,定义并注册商业过程

  exception 异常
  一个在程序执行过程中阻止程序正常执行的事件,通常是一个错误。Java语言通过try,catch和throw关键字支持异常的处理,参见exception
handler

  exception handler
  一段处理特定类型的异常的代码。如果程序能够从异常中恢复过来,那么在处理完异常之后程序可以继续执行。

  executable content
  在HTML文件中执行的应用程序,参见applet。

  extends 继承
  类X 通过extend 类Y来添加功能,或者添加变量,或者添加方法,或者覆盖类Y的方法。一个接口extends另外一个接口来添加方法。类X称为类Y的一个子类,参见derived from

  field 域
  一个类的数据成员。除非显式指明,否则一个field不是static的

  final
  一个Java语言的关键字。你只能定义一个实体一次,以后不能改变它或继承它。更严格的讲:一个final修饰的类不能被子类化,一个final修饰的方法不能被重写,一个final修饰的变量不能改变其初始值。

  finally
  一个Java语言的关键字,用来执行一段代码不管在前面定义的try语句中是否有异常或运行时错误发生。

  float
  一个Java语言的关键字,用来定义一个浮点数变量

  for
  一个Java语言的关键字,用来声明一个循环。程序员可以指定要循环的语句,推出条件和初始化变量。

  FTP
  基本的Internet文件传输协议(File Transfer Protocol)。FTP是基于TCP/IP协议的,它允许在主机之间通过Internet传送文件。参见TCP/IP

  formal parameter list
  在一个方法的定以中指定的参数。参见actual parameter list

  handle
  一个标识enterprise bean的对象。客户可以串行化handle,以后从串行化中恢复handle来得到一个对enterprise bean的引用

  hexadecimal 十六进制的
  使用16作为基的计数系统。记号0-9和a-f(或者A-F)代表了数字0到15。在Java中16进制数必须带有0x前缀。参见octal

  hierarchy
  关系的一种分类,除了最高层的对象(通常称作root),每一个对象有一个专门的上层对象。每个对象可以由一个或多个下层对象在层次关系中。在Java中,root对象是Object

  home interface
  enterprise bean两个接口中的一个。home接口定义了0个或多个方法来创建和删除一个enterprise bean。对于session bean,home接口定义了创建和删除方法,然而对于entity bean,home接口定义了创建,查找和删除的方法。

  home handle
  一个对象,能够用来得到对一个home接口的引用。一个home handle能够被串行化写入持久存储器中,通过反串行化来得到这个引用。
 
  HTML
  HyperText Markup Language的缩写。这是一个文件格式,基于SGML,为了超文本在Internet上的传输。它十分简单,允许嵌入图片,声音,视频流,表单域和简单的文本格式。对其他对象的引用被嵌入到URLs中。

  HTTP
  HyperText Transfer Protocol的缩写。Internet的协议,基于TCP/IP,用来获得远程主机上的超文本。参见TCP/IP。

  HTTPS
  建立在SSL协议之上的超文本传输协议(HTTP)

  IDL
  接口定义语言(Interface Definition Language)的缩写,使用Java(TM)编写的API提供基于标准的和CORBA的交互性和连接性。

  identifier 标识符
  在Java程序中一个对象的名称

  IIOP
  Internet Inter-ORB Protocol的缩写。一个用来在CORBA对象请求代理之间交流的协议。

  if
  Java编程语言的一个关键字,用来生成一个条件测试,如果条件为真,就执行if下的语句。

  implements
  Java(TM)编程语言的一个关键字,在类的声明中是可选的,用来指明当前类实现的接口。

  import
  Java(TM)编程语言的一个关键字,在源文件的开始部分指明后面将要引用的一个类或整个包,这样就不必在使用的时候加上包的名字。

  inheritance 继承
  一个概念:一个类型会自动包含其父类型(supertypes)的变量和方法。参见superclass, subclass。

  initialization parameter
  初始化Servlet上下文的参数。

  instance 实例
  一个特定类型的对象。在Java(TM)语言中,一个对象是由new操作符创建的。
  
  instance method 实例方法
  任何跟一个类的实例相关的方法,也称作method。参见class method。

  instance variable 实例变量
  任何和一个特定对象相关的数据项。每一个类的实例有一份类定义中声明的实例变量的拷贝,也称作field。参见class variable。

  instanceof
  一个二操作数的Java(TM)语言关键字,用来测试第一个参数的运行时类型是否和第二个参数兼容。

  int
  Java(TM)的一个关键字,用来定义一个整形变量

  interface
  Java(TM)的一个关键字,用来定义一系列的方法和常量。它可以被类实现,通过implements关键字。

  Internet
  一个由全球各个组织,各个国家的数百万的主机组成的巨大的一个网络。它是由很多小网络物理的连接在一起而成的,数据通过公共的一组协议传输。

  IP
  Internet Protocol的缩写,Internet的基本协议,它提供不可靠的主机间的数据包的传送。它不保证是否数据包能够正确传送,需要多久的时间来传送,或者当有多个包时是否按顺序到达。建立在该协议之上的协议提供连接和可靠性的概念。参见 TCP/IP.

  interpreter 解释器
  一个可选解码并且执行代码中的每一句语句的模块。Java(TM)解释器解码并执行为符合Java虚拟机规范的字节码。参见compiler, runtime system。

  ISV
  Independent Software Vendor的缩写

本篇文章来自Java中文网:http://javaweb.cc/other/english/2212.shtml

教程由JAVA中文网整理校对发布(javaweb.cc)

       J2EE application
  任何可配置的J2EE功能单元。可能是由一个或多个软件模块与一个J2EE应用程序配置描述符打包成.ear文件。J2EE应用程序通常设计成在多机环境下运行的分布式应用。
 
  J2EE product
  一个遵循J2EE平台规范的实现。

  J2EE Product Provider
  提供J2EE产品的生产商。

  J2EE server
  J2EE Product的运行时部分。一个J2EE提供Web和/或EJB容器。

  JAE
  Java(TM) Application Environment的缩写。Java Development Kit (JDK(TM))的源代码。

  JAR Files (.jar)
  Java ARchive的缩写。一种把许多文件聚合到一个文件的一种文件格式。

  JAR file format
  JAR是一种把许多文件聚合到一个文件的平台无关一种文件格式。许多个用Java编写的applet以及它们所需要的组件(.class文件,图片,声音和其他资源文件)能够被打包到一个JAR文件中,以便以后在单独一个HTTP请求中就能够下载到客户端。它同样支持文件压缩和数字签名。

  Java(TM)
  是Sun公司的商标,标识了一系列在独立的和网络化的环境中创建并安全的运行程序的技术。

  Java Application Environment (JAE)
  Java Development Kit (JDK(TM))的源代码。

  Java(TM) 2 Platform, Standard Edition (J2SE platform)
  核心的Java技术平台

  Java(TM) 2 Platform, Enterprise Edition (J2EE platform)
  一个用来开发和配置企业应用程序的环境。J2EE平台由一系列的服务,应用程序接口(APIs)和提供开发多级的,基于Web的功能的协议组成。

  Java(TM) 2 SDK, Enterprise Edition
  Sun公司的对J2EE平台的一个实现。这个实现提供了一个可操作的J2EE平台的定义。

  JavaBeans(TM)
  一个可移植的,平台无关的,可重用的组件模型。

  Java Blend(TM)
  一个通过映射数据库数据到Java编程环境中的对象(Object)和映射对象到数据库使程序员能够简化数据库应用开发的产品。

  Java Card(TM) API
  一个和ISO 7816-4兼容的应用开发环境,集中在smart card上。

  JavaCheck(TM)
  一个工具,用来检查一个应用程序或一个applet是否符合某个规范。

  Java(TM) Compatibility Kit (JCK)
  一个测试包,一组工具,和其它的一些需求,用来检查一个实现是否和Java平台规范和软件参考实现兼容。

  Java Database Connectivity (JDBC(TM))
  一个Java平台和大量数据库平台之间互联的平台无关的工业标准。JDBC(TM)提供了调用级的API来操作支持SQL语言的数据库。

  Java Developer Connection(SM)
  一个为个人开发者设计的服务,提供在线训练,产品打折,专题文章,错误信息和一些早期的版本兼容性信息。

  Java Development Kit (JDK(TM))
  一个软件开发平台,支持使用Java语言编写Applet或应用程序。

  Java(TM) Enterprise API
  这个API使编写大型的,可能在一个组织中或Internet上与其它应用程序共享多媒体数据的商业或数据库应用程序变得简单。在Java(TM)
Enterprise API家族中已经有四个APIs被设计出来。

  Java(TM) Foundation Classes (JFC)
  一个扩展,把图形用户接口加入到抽象窗口工具集(AWT)中。

  Java(TM) IDL
  一个提供J2EE平台与CORBA交互能力和互联能力的技术。这些兼容性使J2EE应用程序能够通过OMG IDL和IIOP调用远程网络上的操作。

  Java(TM) Interface Definition Language (IDL)
  用Java编写的APIs,提供标准化的与CORBA(Common Object Request Broker Architecture)的交互能力和互联能力。

  Java(TM) Message Service (JMS)
  使用企业级消息系统的API,比如IBM MQ Series,TIBCO Reanezvous等。

  Java Naming and Directory Interface(TM) (JNDI)
  一组用来提供多重命名和目录服务的APIs的集合。

  JavaOS(TM)
  一个基于Java的操作系统,对各种计算和用户平台进行了优化。JavaOS(TM)操作环境提供了一个运行时规范,使Java程序能够直接运行在硬件平台之上而不需要宿主操作系统。

  Java(TM) Platform
  由Java编程语言,一组APIs,类库,其它在开发,编译,错误检查中要用到的程序,和一个能够装载并执行class文件的Java虚拟机组成。

  除此之外,Java平台的目标是提供一组一致的兼容的实现。符合兼容性规范的实现能够得到Sun公司的兼容性标志。

  Java 2是当前的一代Java平台。
 


  Jini(TM) Technology
  一组Java APIs,可能是任何一个Java 2平台的可选包。Jini API使网络设备和服务变得透明,不再需要用户去管理系统或网络使其正常工作。
  Jini在目前是任何一个Java平台版本的一个可选软件包。

  JNDI
  Java Naming and Directory Interface(TM)的缩写,一组用来提供重命名和目录服务的APIs的集合。

  JPEG
  Joint Photographic Experts Group的缩写。 由这个小组建立的一个图象文件压缩标准。它通过几乎察觉不出的图象质量的损失来实现了巨大的图象压缩比。

  JRE
  Java(TM) runtime environment的缩写。一个Java Development Kit (JDK(TM))的子集,适合最终用户和希望重新发布运行环境的开发人员。Java runtime environment由Java虚拟机,Java核心类和支持文件组成。

  Just-in-time (JIT) Compiler
  一个在Java运行时,把所有字节码转换为本地代码的编译器。这样就会加速Java的执行,相对Java虚拟机的解释执行。

  JVM
  参见: Java(TM) Virtual Machine (JVM)


本篇文章来自Java中文网:http://javaweb.cc/other/english/2213.shtml


教程由JAVA中文网整理校对发布(javaweb.cc)

       lexical
  关于如何把源代码翻译成各种编译器能够识别的记号

  literal
  整数,浮点数,字符的基本表示方法。比如,字面上3.0是一个双精度浮点数,"a"是一个字符。

  local variable
  一个块中可见的数据项,但是对块外面的代码是不可见的。比如,任何在一个方法中声明的变量是一个局部变量,不能在方法外面被使用。
 
  long
  Java语言的一个关键字,用来定义一个long类型的变量。
    

  member
  类的一个域或者方法,除非显式指明,否则一个member不是静态的。

  method
  类中定义的一个方法,参见instance method, class method,除非显式指明,否则一个method不是静态的。

  module
  一个软件单位,由一个或多个相同容器类型的J2EE组件和一个相同类型的配置描述符组成。有三种module类型:EJB,Web,和Application Client。模块可以被配置成独立的单元或嵌入到应用程序中。

  Mosaic
  一个提供简单图形界面,使用户能够方便的访问Internet上的数据的程序。这些数据可能是简单文件,或者超文本文档。Mosaic是由NCSA的一个小组编写的。

  multithreaded
  描述一个程序,它的代码被设计成拥有多个同时被执行的部分。参见thread。

        object
  面向对象程序的主要的一个构造块。每一个对象是一个编程单元,由数据(instance methods)和功能(instance methods)组成,参见class。

  object-oriented design
  一个软件设计方法,通过类和对象为抽象和具体的对象的特点建模。

  octal
  使用8作为基的计数系统。使用数字0-7。在Java中8进制数必须带有0前缀。参见hexadecimal。

  One
  Open Net Environment的缩写,由Sun组织,主要工业参与商资助,描述了一个易于理解的体系结构,用来创建,编译和配置Web服务。ONE是平台无关的,基于完全开放的标准。Sun ONE指代一个特定的由Sun和iPlanet提供的对这个体系结构的实现。

  Optional Packages
  一个或多个APIs的集合,在Java平台上,它们是可用的,并且可能在兼容平台上也被支持。
  随着时间推移,Optional Packages可能因为市场需要而变成必需的。

  ORB
  Object Request Broker的缩写。一个函数库,使CORBA对象能够定位另一个对象且和它通讯。

  OTS
  Object Transaction Service的缩写,一组接口定义使CORBA对象能够处理事务。

  overloading
  在同一个作用域里面使用一个标识符指代多个对象。在Java语言中,你可以overload方法,但不能是变量和操作符。

  overriding
  在子类中对在父类中定义的方法提供一个不同的实现。
  re-entrant enterprise bean
  一个enterprise bean,能够被并发的,交叉的,或递归的调用,并且相互之间不干扰。

  reference
  一个内容是地址的数据元素。

  remote interface
  enterprise bean两个接口中的一个。remote接口定义了能够被客户调用的商业方法。

  remove method
  在home接口中定义的方法,客户端可以调用它来删除一个enterprise bean。

  resource adapter
  一个系统级的软件驱动,被EJB容器和应用程序客户用来连接到一个EIS。通常一个resource adapter总是针对某一特定EIS的。它以函数库的形式提供,运行在使用它的服务器或客户地址空间中。一个resource adapter插入到一个容器中。应用程序组件配置容器,然后使用客户端API(由adapter提供的)或者由高层抽象生成的工具来访问下面的EIS。resource adapter和EJB容器配合提供与EIS连接的下层机制 - 事务,安全,和连接池。

  resource manager
  提供访问一组共享对象的能力。一个recource manager参与一个被事务管理器外部控制和调整的事务。一个resource manager通常和访问它的客户运行在不同的主机上和不同的地址空间中。

  resource manager connection
  代表一个和资源管理器的会话的对象。

  resource manager connection factory
  一个用来创建资源管理器对象的对象。
本篇文章来自Java中文网:http://javaweb.cc/other/english/2214.shtml

教程由JAVA中文网整理校对发布(javaweb.cc)

       role (development)
  在开发和配置一个基于J2EE技术的应用程序的过程中某个对象起到的作用。role有:应用程序组件提供者,应用程序编译者, 应用程序配置者
, J2EE平台提供者, EJB容器提供者, EJB容器提供者, Web容器提供者, Web服务器提供者,工具提供者和系统管理员。

  role (security)
  一个抽象的逻辑的用户组,由Application Assembler定义。当一个application被配置的时候,roles被映射到安全标识,比如负责人或者组,在操作和环境中。

  role mapping
  把由容器所识别的组和负责人和由配置描述符定义的安全角色联系起来的一个过程。在组件被安装到服务器之前,安全角色必须被配制器映射。

  rollback
  当一个事务中所有的对数据库的更新被取消的一个点。

  root
  在对象层次中的一个对象,所有对象都是从它继承而来的,root对象在层次图中没有上层对象,参见hierarchy, class, package。

  RPC
  Remote Procedure Call的缩写。通过向远程主机发送网络数据包执行,看上去就跟普通的调用过程(或方法调用)是一样的,

  runtime system
  一个软件环境,其中能够运行为Java虚拟机编译的程序。runtime system包含了为了装入用Java编写的程序,动态连接本地方法,内存管理,异常处理和实现一个Java虚拟机(可能是Java一个解释器)所必须的代码。SAX
  Simple API for XML的缩写。一个为访问XML文档提供的事件驱动的,串行访问的机制。

  Sandbox
  由许多的系统组件组成,从作为应用程序一部分运行的安全管理器,到Java虚拟机中的和语言本身的安全措施。SandBox保证一个不可信任的,可能恶意攻击的应用程序不能访问系统资源。

  scope
  一个特性标识,用来规定哪些地方标识符是可见的。Java环境中的大多数标识符拥有类或者局部的scope。实例变量和类变量有类的scope;它们在类的外部或者子类中使用时必须在它们前面加上一个类名前缀(对类变量和类方法)或者类实例名。所有其他的在方法内部定义的变量具有局部scope;它们只能在封闭的块中使用。

  Secure Socket Layer (SSL)
  一个为了个人隐私在Web服务器和浏览器之间进行加密的协议。

  security attributes
  一组和负责人相关联的属性。Security attributes能够和一个负责人相关联,通过J2EE产品提供商制定的认证协议。

本篇文章来自Java中文网:http://javaweb.cc/other/english/2215.shtml


教程由JAVA中文网整理校对发布(javaweb.cc)

       security constraint
  一个明确的方法来注释想要的对Web内容的保护。一个security constraint由一系列Web资源,一个认证限制和用户数据限制组成。

  security context
  一个对象,封装了跟安全有关的两个实体之间的共享状态信息。

  security permission
  由J2SE定义的J2EE平台用来表述应用组件供应商必须遵循的编程限制的一个机制。

  security permission set
  J2EE产品提供商为每一个组件类型的执行所必须提供的安全允许的最小集合。

  security policy domain
  一个作用域,其中安全策略被定义并且由安全管理员强制执行。一个security policy domain有以下的几个特征:
   它有一组用户(或者负责人)
   它有一个很好定义的认证协议来认证用户
   它可能有组的概念来简化安全策略的设置

  security technology domain
  一个作用域,其中同样的安全机制被用来强制执行一个安全策略。在单个technology domain中可以存在多个security policy domain。

  server principal
  服务器在操作系统中执行的地位。

  servlet
  一种扩展Web服务器功能的Java程序,动态生成文档,并且使用使用请求应答的方式和用户交互。
 
       stream
  Stream是一个简单的从发送着到接受者的数据字节流。有两种基本的分类,所以java.io包包含两个抽象类(InputStream和OutputStream)。
 
  subarray
  一个在另一个数组中的数组。

  subclass
  从某个类派生出来的类,可能是和一个或多个类之间的关系。参见superclass, supertype。

  subtype
  如果类型X继承或者实现了类型Y,那么X是Y的一个subtype。参见supertype。

  superclass
  一个类,某个类是从它派生而来的,可能是和一个或多个类之间的关系。参见subclass, subtype。

  super
  Java语言的一个关键字,用来访问父类的类成员。

  supertype
  一个类型的父类型是指它所实现的所有接口和继承的类型,参见subtype, superclass。

  switch
  Java语言的关键字,用来计算一个变量,在后面用来匹配由case语句指定的值,以决定执行哪一组语句。

  Swing Set
  一系列图形用户接口GUI)组件的代码名称,能够在任何支持Java虚拟机的本地平台上一致的运行。因为它们是完全用Java语言编写的,这些组件可能提供的功能比本地平台提供的等价功能更为强大。(和AWT对比)

  synchronized
  Java语言的关键字,当它用来修饰一个方法或者一个代码块的时候,能够保证在同一时刻最多只有一个线程执行该段代码。(
 
  TCP/IP
  Transmission Control Protocol based on IP的缩写。这是一个Internet协议,提供可靠的基于流的从一个主机到另一个的数据传输。参见IP。

  Technology Compatibility Kit (TCK)
  一个测试包,一组工具,和其它必需的东西,用来证明一个特定的Sun的技术的实现是否和应用程序规范兼容或者是否和Sun和Sun设计的参考实现兼容。

  this
  Java语言的关键字,用来代表它出现的类的一个实例。this可以用来访问类变量和类方法。
 
 

  UDDI
  Universal Description Discovery and Integration的缩写。UDDI提供了一个全局的,公共的,基于XML的,在线的商业注册,商业用户通过它可以注册并宣传它们的Web服务。UDDI定义Internet版的白页和黄页电话号码本。

  Unicode
  ISO 10646定义的16位长的字符集。参见ASCII。Java环境中所有的源代码都是用Unicode编写的。

  URI
  Uniform Resource Identifier的缩写。一个用来标识抽象或物理资源的简洁字符串。一个URI或者是一个URL或者是一个URN。URLs和URNs是具体的确实存在的实体。URI是一个抽象的父类。

  URL
  Uniform Resource Locator的缩写。一个使用文本指代WWW网站上任意数据的标准。一个URL通常是这样的"protocol://host/localinfo",protocol指明传输对象的时候使用的协议(比如HTTP或FTP),host指明在Internet上找到一台主机的名字,localinfo是一个传递给远程主机上协议处理器的字符串(常常是一个文件名)。

  URL path
  通过一个HTTP请求传递的URL,来使用一个servlet。URL由Context Path + Servlet Path + PathInfo组成,其中被请求的servlet是与Context Path相关联的servlet上下文的一部分。如果这个上下文是默认的上下文,以Web服务器的URL名字空间的基目录为根,那么这个路径前缀将会是一个空字符串。否则这个路径前缀以/开始,但是不是以/结束。Servlet Path部分直接和激活这个请求的映射对应。这个路径以/字符开始。PathInfo是请求路径的一部分,但不是Context Path或者Servlet Path的一部分。

  URN
  Uniform Resource Name的缩写。唯一标识一个实体的标识符,但是不能给出实体的位置。系统可以先在本地寻找一个实体,在它试着在Web上找到该实体之前。它也允许Web位置改变,然而这个实体却还是能够被找到。
 
  variable
  由一个标识符命名的数据项。每一个variable有一种类型,比如一个整数或者一个对象,和一个作用域。参见class variable, instance variable, local variable。

  virtual machine
  一个抽象的计算设备规范,可以使用不同的方法实现,软件的或者硬件的。你把程序编译成virtual machine的指令集和你把程序编译成微处理器指令集是十分相似的。Java(TM) virtual machine*由字节码指令集合,一组寄存器,一个堆栈,一个垃圾收集堆和一个存放方法的区域
本篇文章来自Java中文网:http://javaweb.cc/other/english/2216.shtml

教程由JAVA中文网整理校对发布(javaweb.cc)

       vocabulary
  传统上,软件程序被编写,然后编译成直接和计算机中驱动微处理器工作的操作系统相关的机器码。Java平台通过提供一个程序编写编译,然后能够通过网络传输并且在任何由足够兼容性的虚拟机的平台上运行的模型减轻了这种依赖型。

  这个模型提供了额外的好处,高安全性,即因为程序可以被虚拟机验证一致性在通过网络传输之后,也因为虚拟机运行在安全的"sandbox"的中,能够阻止一些特定的破坏性的行为。

  软件开发人员已经投入Java语言的怀抱,因为它减少了编写程序和支持软件代码的费用和时间。他们不再需要为不同的操作系统和不同的微处理器重新编写功能相同的代码。正在配置应用程序的公司和组织喜欢Java,因为它减少了购买和修改不同版本的应用程序使其适应各自网络环境中各种类型的计算机和服务器的费用。

  void
  Java语言的关键字,用在Java语言的方法声明中说明这个方法没有任何返回值。"void"也可以用来表示一句没有任何功能的语句。

  volatile
  Java语言的关键字,用在变量的声明中表示这个变量是被同时运行的几个线程异步修改的。
  一个UNIX命令,使用它将会等待所有的后台进程结束,并且报告他们的结束状态。

  Web application, distributable
  用J2EE技术编写的应用程序,所以它可以被配置到一个分布运行在一台或多台主机的多个Java虚拟机中的Web容器中。这种类型的应用程序的配置描述符使用可分布的元素。

  Web component
  一个通过相应为请求提供服务的组件,或者是一个Servlet或者是一个JSP页面。

  Web container
  实现J2EE体系结构中Web组件协议的容器。这个协议规定了一个Web组件运行时的环境,包括安全,一致性,生命周期管理,事务,配置和其它的服务。一个提供和JSP和J2EE平台APIs界面相同服务的容器。一个Web container 由Web服务器或者J2EE服务器提供。

  Web container, distributed
  一个Web容器,能够运行一个标记为分布式的,在同一台主机或不同主机上的多个Java虚拟机中运行的Web应用程序。

  Web server
  提供访问Inetrnet,Intranet或者Extranet服务的软件。一个Web server运行在Web站点上,提供对HTTP和其它协议的支持,并且运行服务器端的程序(比如CGI脚本或者servlets)来实现一定的功能。在J2EE体系结构中,Web Server为Web容器提供服务。比如,一个Web容器通常依靠Web Server来处理HTTP消息。J2EE平台假设一个Web容器总是运行在同一个厂商提供的Web Server之上,所以没有制定这两个实体之间的协议。一个Web Server可以运行一个或多个Web容器。

 

posted @ 2012-08-18 19:48 、小细 阅读(110) | 评论 (0)编辑 收藏
     摘要: IO包中的其他流:   1.打印流 a)PrintWriter(写-->print打印) 与PrintStream  (字符流) 1 PrintWriter用法一:其实它是对一个Writer进行了封装 2 package com.javami.kudyTest; 3 import java.io.FileNotFoundExce...  阅读全文
posted @ 2012-08-14 13:10 、小细 阅读(127) | 评论 (0)编辑 收藏
     摘要: File类:用来将文件或者文件夹封装成对象方便对文件或者文件夹的操作File对象可以作为参数传递给一个流.递归:函数自己调用自己应用场景:当某一个功能需要重复调用..1.遍历一个文件,并且让让这个文件写入到一个文本里面,(需要树状的排序) 1 package com.javami.kudy.CodeAM; 2 import java.io.BufferedWriter; 3 imp...  阅读全文
posted @ 2012-08-11 22:48 、小细 阅读(168) | 评论 (0)编辑 收藏
     摘要: 字节流的抽象基类: InputStream(输入)  OutPutStream(输出) 字符流的抽象基类: Reader(读)       Writer(写) 这四个类派生出来的子类都是由父类的名作为子类名的后缀.   IO需要了解的问题: 1.有了垃圾回收站为什么还要调用close方法去进行关闭 解答...  阅读全文
posted @ 2012-08-08 13:06 、小细 阅读(388) | 评论 (0)编辑 收藏

IO(Input OutPut)流

IO流用来处理设备之间的数据传输

JAVA对数据的操作是通过流的方式

JAVA用于操作流的对象都在IO包中

流按操作对象分为两种: 字节流,字符流

流按流向分为: 输入流,输出流.

其它的内容还是比较简单的,注意的是以下这几个自定义包装类:

实现1.

MyBufferedReader.class

 1 package com.javami.kudy.Code13;
 2 import java.io.IOException;
 3 import java.io.Reader;  //读取字符流的抽象类
 4 import java.io.IOException;
 5 /*
 6  * 自定义MyBufferedReader包装Reader,提供了一个缓冲区的功能.提供了ReadLine功能.
 7  * 1.用一个次组合,拿到被包装的Reader对象
 8  * 2.定义一个字符数组作为缓冲区
 9  * 3.实现一个read方法,填充缓冲区,从缓冲区那里返回一个字符
10  * 4.定义一个readLine方法,内部调用read方法,循环读取一行,进行返回
11  * 5.定义一个close方法,关闭地底层所包装的流
12  */
13 public class MyBufferedReader  extends Reader{
14     private Reader r;
15     char[] buf = new char[1024];
16     int len =0;
17     int pos = 0;
18     public MyBufferedReader(Reader r)
19     {
20         this.r = r;
21     }
22     /*
23      * 实现read()方法,实现缓存的功能
24      * 分析:
25      * 1.当别人第一次调用该方法的时,一次性的去填充缓冲区
26      * 2.定义一个len变量记住缓冲区的可用字符的数量
27      * 3.将数组的第一个元素返回
28      * 4.当别人第二次调用的时,将数组的二个元素返回
29      * 5.每次返回元素 len --
30      * 6.当len为零时,说明数组没有可用字符啦,那么这时候返回一个-1
31      * 
32      * 思路:
33      * 1.定义两个成员变量,len记住可用字符数量,pos记住当前字符的角标
34      * 2.判断len是否为0,如果为零要填充缓冲区.并且pos为零
35      * 3.判断len,如果为-1,则返回-1
36      * 4.将pos位置的元素返回.pos++
37      */
38     public int read() throws IOException
39     {
40         if(len ==0)
41         {
42             len = r.read(buf);
43             pos = 0;
44         }
45         if(len==-1)
46             return -1;
47         len--;
48         return buf[pos++];
49     }
50     
51     /*
52      * 实现readLine方法,实现读一行的功能,
53      * 1.循环调用自己的方法的read方法,读取字符
54      * 2.知道回车的字符,方法就结束
55      */ 
56     public String readLine() throws IOException
57     {
58         StringBuilder sb = new StringBuilder();
59         int ch;
60         while((ch=read())!=-1)
61         {
62             if(ch=='\r')
63                 continue;
64             if(ch=='\n')
65                 break;
66             sb.append((char)ch);
67             if(ch==-1&&sb.length()==0)
68                 return null;
69         }
70         return sb.toString(); //转换成字符串
71     }
72     @Override
73     public void close() throws IOException {
74         r.close();
75     }
76 
77     @Override
78     public int read(char[] cbuf, int off, int len) throws IOException {
79         int count=0;
80         for(int i=0; i<off+len; i++)
81         {
82             int ch = read();
83             if(ch==-1)
84                 break;
85             count++;
86             buf[i] = (char)ch;
87         }
88         return count;
89     }
90 
91     
92     
93 }

MyBufferedWriter.class  这个主要是写入

 1 package com.javami.kudy.Code13;
 2 import java.io.IOException;
 3 import java.io.Writer;
 4 
 5 public class MyBufferedWriter  extends Writer{
 6     
 7     private Writer w;
 8     private char[] buf = new char[1024];
 9     private int pos = 0;
10     
11     public MyBufferedWriter(Writer w)
12     {
13         this.w = w;
14     }
15     /*
16      * 定义Writer方法,实现写一个字符,实现缓存的功能
17      * 1.定义一个变量pos记住当前的写入位置
18      * 2.每次调用都使用这个方法都会传入一个字符,将字符缓存到数组pos位置里面去
19      * 3.pos++
20      * 4.每次上来就判断,如果pos =1024,刷新缓冲区 ,pos = 0
21      */
22     public void Writer(int ch)throws IOException
23     {
24         if(pos == 1024)
25         {
26             flush(); //刷新一下缓冲区.并且初始化为零
27             pos = 0;
28         }
29         buf[pos++] = (char)ch;
30     }
31     @Override
32     public void close() throws IOException {
33         flush();
34         w.close();
35     }
36 
37     @Override
38     public void flush() throws IOException { 
39         w.write(buf,0,pos); //把buf0-pos位置的内容写入进去
40     }
41     public void writer(String data)throws IOException
42     {
43         char[] chars = data.toCharArray(); //转换成字符
44         for(char c : chars)
45             write(c);
46     }
47     public void newline()throws IOException
48     {
49         write("\r\n"); //所谓的换行就是一个
50     }
51     @Override
52     public void write(char[] cbuf, int off, int len) throws IOException {
53         for(int i=0; i<off+len; i++)
54         {
55             w.write(buf[i]);
56         }
57         
58     }
59 
60 }

由于每次都要关闭流啊~~无奈.只好使用一个类来实现它们

CloseUtil.class

 1 package com.javami.kudy.Code13;
 2 import java.io.IOException;
 3 import java.io.Reader;
 4 import java.io.Writer;
 5 public class CloseUtil {
 6     private CloseUtil(){}
 7     public static void close(Reader r,Writer w)throws IOException
 8     {
 9         try
10         {
11             if(r!=null)
12                 r.close();
13         }
14         finally
15         {
16             if(w!=null)
17             w.close();
18         }
19     }
20 }

一个简单的测试类:

 1 package com.javami.kudy.Code13;
 2 import java.io.FileReader;
 3 import java.io.FileWriter;
 4 import java.io.IOException;
 5 
 6 public abstract class BufferedTest {
 7 
 8     /**
 9      * @param args
10      */
11     public static void main(String[] args)
12     {
13         MyBufferedReader mr = null;
14         MyBufferedWriter mw = null;
15         try
16         {
17             mr = new MyBufferedReader(new FileReader("src/a.txt"));
18             mw = new MyBufferedWriter(new FileWriter("src/b.txt"));
19             int len;
20             while((len=mr.read())!=-1)
21             {
22                 mw.Writer(len);
23             }
24         }
25         catch(IOException e)
26         {
27             e.printStackTrace();
28         }
29         finally
30         {
31             try
32             {
33                 CloseUtil.close(mr, mw);
34             }
35             catch(IOException e)
36             {
37         }
38         }
39     }
40 }

BufferedReader 与 BufferedWriter 的存储图:

以上这几个都是比较难理解的..~~

 

加油啦..

 

posted @ 2012-08-08 01:40 、小细 阅读(71) | 评论 (0)编辑 收藏

Map集合


1.Map存储了一系列键值的映射关系
2.Map集合需要保证键的唯一性
3.可以通过键获取到值,反之则不能
4.Map集合存储元素使用put(key,valus)方法.
5.遍历Map集合的两种遍历方式
a)通过KeySet方法返回由键组成的集合,迭代集合里面的元素拿到所有的键再通过get方法根据键来获取值
b)通过entrySet方法返回键所映射的关系组成的集合,迭代该集合就拿到一个键值映射的关系,再通过getKey获取到键,再通过getValue()方法获取到值


HashMap
线程不安全,存储速度快,允许存放null键,null值
通过HashSet保持键的唯一性

Hashtable
线程安全,存储速度慢,不允许存放null键与null值

TreeMap
通过二叉树的原理保证了键的唯一性
对键进行了排序,排序原理与SetMap相同.
(如果想要使用这个方法,必须要冲构造方法里面重写Comparator 或者从对象所属的类继承Comparator实现这个接口)

Properties
Hashtable的子类,所以是线程安全的.
用于读写配置文件,一般配置项等号两边都是String,所以集合中的两个列保存的都是String类型的数据.
这个集合中只能存String,所以不能使用泛型.


/*JavaAPI总结:application programming interface应用程序编程接口 sun公司提供给我们用的程序
一、String、StringBuffer、StringBuilder
1、String类是字符串常量
2、String池:String s = "abc" 和String s = new String("abc")的区别
3、String类的常用方法:charAt、indexOf、toCharArray、substring、split、compareTo、equals
4、StringBuffer:字符串容器,长度可变,一般用于字符串的增减删的操作。reverse方法反向
String s = "abc"; s = s + "xxx";//String长度不可变,因为是常量
5、StringBuilder线程不安全,StringBuffer线程安全

二、集合类
|-Iterable:实现增强for循环
|--Collection:单列,按照一种或多种规则来存储一系列元素
|---List:有序,允许有重复元素
|----AbstractList:抽象类,实现了iterator方法。
|-----ArrayList:数组实现,查找块,增删慢
|-----Vector:和ArrayList一样,只是线程安全
|-----LinkedList:链表实现,查找慢,增删块
|---Set:无序,不允许有重复元素
|----HashSet:通过哈希算法保证元素不重复,对象要正确重写equals和hashCode方法
|----HashTable:同上,但是线程安全
|----TreeSet:通过树状结构保证元素不重复,两种方式
1、按照元素的自然顺序进行排序,前提是元素具备比较功能,实现了Comparable接口的compareTo方法
2、在构造TreeSet实例时,传入一个比较器,实现Comparator接口的compare方法

|-Map:保存的是键值对应关系,其中键不允许有重复,可以通过keySet方法拿到一个包含所有键的Set
再调用get(key)方法通过键拿到value
|--HashMap:通过HashSet的原理保证键不重复。
|--TreeMap:通过TreeSet的原理保证键不重复
|--Properties:用于读取配置文件,不需要声明泛型,因为键和值都只能为String类型。
list方法将集合中的配置项输出到一个打印流
load方法将一个输入流中的配置项存到集合中
Jdk1.5新特性泛型,减少集合存元素时错误发生的几率。
Jdk1.5出现Iterable,为了实现增强for循环 for(元素类型 变量:集合或数组)

工具类:
Collections:集合工具类,sort、binarySearch、reverse
Arrays:数组工具类,sort。。。。


三、包装类
1、Integer x = 0;x = x + 1; 装箱-拆箱-装箱(jdk1.5)
2、Interger.parseInt(String)将字符串转为int型

四、System类
1、System类的常用方法:gc()垃圾回收、exit(0)终止程序、currentTimeMillis()获得自1970年1月1日零时
以来的毫秒数、getProperty方法获得系统属性。
2、两个静态成员变量:in和out
in:标准输入流,InputStreamReader类型
out:标准打印流,PrintStream类型

五、Runtime类
表示运行时,exec方法,在后台新开启一个窗口运行命令,是当前窗口的子窗口,继承所有窗口属性

六、日期对象
1、Date:大部分方法已过时,用new Date()创建日期对象表示当前时间
2、DateFormat:将日期格式化,抽象类
DateFormat df = DateFormat.getInstance(); String dateStr = df.format(new Date);
3、Calendar对象:
Calendar c = Calendar.getInstance();
可以将类中定义的常量当做参数传入get和set方法来获得和设置时间。
add方法,增加时间值,具体增加哪一项,就看传入的常量,调用完此方法,时间对象就被改变了。
*/

面试题目总结:

一、请说说ArrayList、Vector和LinkedList的区别
这三者都是单列集合Collection下List集合的实现类,所以他们的共同点,元素有序,允许重复元素
不同点:
ArrayList和Vector底层都是数组实现,这样的实现注定查找快、增删慢
ArrayList和Vector的区别在于线程安全问题,Vector支持线程同步,是线程访问安全的,而ArrayList线程不安全
LinkedList底层是链表结构,查找元素慢、增删元素速度快,线程不安全。

二、请说说HashSet原理,并写程序证明
HashSet在存元素时,会调用对象的hashCode方法计算出存储位置,然后和该位置上所有的元素进行equals比较,
如果该位置没有其他元素或者比较的结果都为false就存进去,否则就不存。
这样的原理注定了元素是按照哈希值来找存储位置,所有无序,而且可以保证无重复元素
我们在往HashSet集合存储元素时,对象应该正确重写Object类的hashCode和equals方法
正因为这样的原理,HashSet集合是非常高效的。
比如,要查找集合中是否包含某个对象,首先计算对象的hashCode,折算出位置号,到该位置上去找就可以了,而不用和所有的元素都比较一遍

三、Collection和Collections的区别
两者没有任何关系
Collection是单列集合的父接口,JDK1.5中定义了Iterable接口作为Collection父类,为了实现增强for循环
Collections是工具类,提供了关于集合的常用操作,例如,排序、二分法查找、反转元素等

 

  1 Collections 的应用:
  2 
  3 1.
  4 package com.javami.kudyMap;
  5 import java.util.ArrayList;
  6 import java.util.Collections;
  7 import java.util.Comparator;
  8 import java.util.List;
  9 public class ColletionsTest {
 10     public static void main(String[]args)
 11     {
 12         /*
 13          * Collections工具类:提供关于集合的常用操作.
 14          */
 15         ArrayList<String> al = new ArrayList<String>();
 16         al.add("ab");
 17         al.add("aadc");
 18         al.add("aaa");
 19         al.add("hgdfakjg");
 20         al.add("xhyns");
 21         al.add("yyiouop");
 22         al.add("qq");
 23         al.add("zdff");
 24         
 25         /*
 26         for(String s : al)
 27             System.out.println(s+" ");
 28         */
 29         
 30         /*Collections.sort(al);  //list是一个接口  父类型的应用可以指向子类型的对象..
 31         for(String s : al)
 32             System.out.println(s+" ");*/
 33         Collections.sort(al, new StringComparator());
 34         /*
 35          * 第一种方法 : 通过比较器来对比排序   可以在构造方法里面.
 36          * 或者在对象里面实现这个比较器.当new 这个实现接口.它会自动调用比较器的方法进行比较
 37         */
 38         System.out.println("通过StringComparator()方法已经排序好-----");
 39         for(String s : al)
 40             System.out.print(s+" ");
 41         /*
 42          * 使用了API里面的方法!
 43         //binarySearch(List<? extends T> list, T key, Comparator<? super T> c) 
 44         int pos = Collections.binarySearch(al,"aaa",new StringComparator());
 45         System.out.println(pos);//因为我们需要通过比较才可以!
 46         */
 47         int pos = MyCollections.binarySearch(al,"dasdas",new StringComparator());
 48         System.out.println(pos);
 49     }
 50     
 51 }
 52 
 53 /*
 54  * 比较器: 先比较  长短,再比较顺序
 55  */
 56 class StringComparator implements Comparator<String>
 57 {
 58 
 59     @Override
 60     public int compare(String s1, String s2)
 61     {
 62         //首先比较长度,再按照字典顺序
 63         int num = s1.length()- s2.length();
 64         if(num !=0)
 65             return num;
 66         return s1.compareTo(s2);
 67         
 68     }
 69     
 70 }
 71 
 72 //实现一个二分查找
 73 class MyCollections
 74 {
 75     private MyCollections(){}//私有化
 76     public static<T> int binarySearch(List<T> l,T key,Comparator<T> com)
 77     {
 78         int min = 0;
 79         int max = l.size()-1;
 80         int mid = 0;
 81         while(max >=min)
 82         {
 83             mid = (min+max) / 2;
 84             //判断比较器里面有没有!
 85             if(com.compare(key,l.get(mid))>0)//找到集合位置的值
 86                 min = mid+1;
 87             else if(com.compare(key, l.get(mid))<0)
 88                 max = mid-1;
 89             else
 90                 return mid;
 91         }
 92         
 93         //判断mid位置的元素和key的大小
 94         if(com.compare(key, l.get(mid))>0)
 95             return -mid-2;
 96         return -mid-1;
 97             
 98     }
 99 }
100 
101 2.必须要通过比较器比较才能实现二分查找:
102 
103 package com.javami.kudyAPI;
104 import java.util.ArrayList;
105 import java.util.Collections;
106 import java.util.Comparator;
107 
108 public class Test {
109     public static void main(String[]args)
110     {
111         ArrayList<String> al = new ArrayList<String>();
112         al.add("as");
113         al.add("scx");
114         al.add("dsad");
115         al.add("hellsda");
116         al.add("dsazxc");
117         al.add("dascxxc");
118         //在通过二分查找之前我们要经过排序'
119         System.out.println("还没有排序之前");
120         for(String s : al)
121             System.out.print(s+" ");
122         
123         
124         //第二部 : 当你调用二分查找之后.会调用比较器进行比较.是经过排序后的才可以进行二分查找
125         //比较器一定要传过来
126         int num = Collections.binarySearch(al, "dsaas",new Comparator<String>(){
127 
128             @Override
129             public int compare(String s1, String s2) {
130                 int num = s1.length() - s2.length();//比较长度
131                 if(num != 0)
132                     return num;
133                 return s1.compareTo(s2); //按字典顺序排
134             }
135             
136         });
137         System.out.println(num+1);
138     }
139 }
140 
141 
142 日期的应用:
143 
144 package com.javami.kudyAPI;
145 import java.util.Calendar;
146 public class CalendarTest {
147 
148     /**
149      * @param args
150      */
151 
152     public static void main(String[] args)
153     {
154         Calendar calendar = Calendar.getInstance();
155         printCalendar(calendar);
156         int nums = getDayNum(2012);
157         System.out.println(nums);
158         
159         //----------------
160         Calendar startDay = Calendar.getInstance();//获取当前的日历
161         Calendar finishDay = getFinishDay(startDay);
162         int num = finishDay.get(Calendar.DAY_OF_YEAR) - calendar.get(Calendar.DAY_OF_YEAR);
163         System.out.println(num+"天数");
164     }
165     
166     //计算出某年的2月份有多少天
167     public static int getDayNum(int year)
168     {
169         //1.获取一个日历
170         Calendar calendar = Calendar.getInstance();
171         
172         /*
173          * set(int year, int month, int date) 
174           设置日历字段 YEAR、MONTH 和 DAY_OF_MONTH 的值。
175          */
176         calendar.set(year,2,1); //2月份其实就是中国的三月
177         //日历字段  DAY_OF_YEAR获取到年中的月份  , -1  其实就是2月份
178         calendar.add(Calendar.DAY_OF_YEAR,-1);
179         return calendar.get(Calendar.DAY_OF_MONTH); //获取到二月份的天数
180     }
181     
182     //一个项目做100天,周末休息,五一和十一各休息一天,今天开始做,哪天完工
183     //一个项目做100天,周末休息,五一和十一各休息一天,今天开始做,哪天完工
184     public static Calendar getFinishDay(Calendar c) {
185         for(int i=0; i<100; i++) {
186             
187             //如果是星期六或者星期天(get 和 set 的字段数字,指示一个星期中的某天。)
188             if(c.get(Calendar.DAY_OF_WEEK)==1||c.get(Calendar.DAY_OF_WEEK)==7)
189                 i--;
190             //(get 和 set 的字段数字,指示一个月中的某天。)
191             else if(c.get(c.DAY_OF_MONTH)==1&&(c.get(c.MONTH)==4||c.get(c.MONTH)==9))
192                 i--;
193             c.add(Calendar.DAY_OF_YEAR, 1);
194         }
195         return c;
196     }
197     //代表是一个时间
198     public static void printCalendar(Calendar calendar)
199     {
200         int year = calendar.get(calendar.YEAR); //
201         int month = calendar.get(calendar.MONTH); //
202         int day = calendar.get(calendar.WEEK_OF_MONTH);//
203         int week = calendar.get(calendar.DAY_OF_WEEK);//星期
204         int hour = calendar.get(calendar.HOUR_OF_DAY); //时间
205         int minute = calendar.get(calendar.MINUTE);//
206             
207         String StringWeek = null;
208         switch(week)
209         {
210         
211             case 1:
212                     StringWeek = "星期天";
213                     break;
214             case 2:
215                     StringWeek = "星期一";
216                     break;
217             case 3:
218                     StringWeek = "星期二";
219                     break;
220             case 4:
221                     StringWeek = "星期三";
222                     break;
223             case 5:
224                     StringWeek = "星期四";
225                     break;
226             case 6:
227                     StringWeek = "星期五";
228                     break;
229             case 7:
230                     StringWeek = "星期六";
231                     break;
232         }
233         //并接成字符串
234         String str = ""+year+"-"+(month+1)+"-"+day+"-"+week+"-"+hour+"-"+minute;
235         System.out.println(str);
236     }
237 
238 
239 }
posted @ 2012-08-07 01:10 、小细 阅读(253) | 评论 (0)编辑 收藏


集合类:

为什么使用集合类?

在面向对象的编程思想中,都是以对象的形式对事物进行描述的,为了保证对象的生命周期,我们需要持有对象
(什么叫做持有对象呢?Person p = new Person())

数组和集合类的区别?

1.数组和集合类都是容器,都能存储对象
2.集合类优点就是长度可变,而数组一旦定义.长度是不能修改的.


集合的特点:

集合类可用于存储对象.
集合类的长度可变
一个集合可以存储多种类型的对象..

Collection 接口:
1.一个独立的元素的序列,这些元素从一条或多条规则
2.collection接口下分为list集合和Set集合
3.list集合的特点是元素有序,可以允许有重复的元素
4.set集合的特点是元素无序,不允许有重复的元素
↓↓
List(子接口)
↓↓
ArrayList(实现类)
1.底层数组实现,查找快,增删慢
2.线程不安全
----------------------------------
Vector(实现类)
1.与ArrayList基本一样
2.线程安全
----------------------------------
LinkedList(实现类)
1.底层是链表的实现
2.增删快,查找慢


{
List集合元素存取方法一致
使用add()方法增加元素
由于List集合有序,可以使用get()方法获取元素
元素的迭代(Iterator)
通过集合对象的iterator()方法获得迭代器Iterator
通过Iterator迭代器的hasNext()方法判断是否存在下一个元素
通过Iterator迭代器的next()方法获取下一个元素
元素的迭代(Enumeration)
迭代Vector集合中的元素可以使用Enumeration
通过Enumeration的hasNextElements()方法判断是否还有元素
通过Enumeration的nextElement()方法返回下一个元素
}


↓↓
Set(子接口)
↓↓
Set集合无须,不允许有重复的元素
1.set集合通过存入对象的equals方法来保证集合中没有重复的元素

HashSet(实现类)
HashSet是set的子类,因而没有重复元素
底层使用了哈希算法保证没有重复元素
存储对象时,先调用对象的HashSet()方法,找到存储位置,再和当前的存储位置上已经存在的元素通过equals()方法进行比较,如果返回false,才能进行存储
往HashSet集合里存储的对象必须是重写HahCode 和equals()方法。

TreeSet(实现类)
TreeSet集合通过二叉树算法保证无重复元素,并对元素进行排序
第一种方式: 如果对象实现了Comparable接口,就可以存入TreeSet集合 因为它会自动的去调用里面的一个比较方法.所以在Person里面重写
第二种方式: 如果对象没有实现Comparable接口,在创建TreeSet对象时,需要给构造函数扔进一个比较器,实现Comparator接口 .(必须要在匿名内部类重写.或者继承一个类来重写)

----------------------------------

Map接口:
1.一组成对的“键值对”对象,允许根据键来查找值
2.Map集合的健值不允许有重复的,所以Map所有的键都构成了一个Set集合

Iterable接口:
1.JDK1.5新定义的接口作为Collection的父接口
2.主要就是实现了增强for循环

 

jdk1.5的新特征:

泛型:
由于集合可以存储不同数据类型的对象,所以取元素(地址)时会导致类型转换错误
jdk1.5新增加了泛型,为了减少操作集合的出错里
例如: ArrayList<Person> arraylist = new ArrayList<Person>();
比喻: 我在每一个挂了一个牌子.只能是Person 使用.做了一个限制..

使用泛型的好处:
1.提高的代码的安全性
2.讲运行期间的问题转到了编译期间的问题(你懂的~~)
3.省起了类型转换的麻烦
4.泛型类的出现优化了程序设计

增强for循环:
新接口Iterable中定义了增强for循环
可以通过增强for循环对数组和集合进行遍历
在迭代集合元素时,需要定义了泛型才能使用for循环

可变参数:

有的时候在设计方法时无法确定将来别人会传入的参数个数
JDK1.5增加了新特性可变参数,在函数中只声明参数类型,不规定个数
方法接受的参数实际上是一个数组,可以在方法中遍历数组
可变参数只能被定义为函数的最后一个形参
语法格式: 返回值 函数名(参数类型… 形参)

 

 1 package com.javami.kudy.javaapin.StringStudy;
 2 
 3 public class Test {
 4         public static void main(String[]args)
 5         {
 6             show(33,45,7657,332,11,5465);
 7         }
 8         
 9         public static void show(int ... i)
10         {
11             for(int num : i)
12                 System.out.println(num);
13         }
14 }
posted @ 2012-08-07 01:09 、小细 阅读(85) | 评论 (0)编辑 收藏

第一:

package com.javami.kudy.javaapi1.StringStudy;

public class StringDemo {
    /*面试题:
     * 1.Stirng s = "abc" String s = new String("abc"); //有什么区别?
     * 2.String s = new String("abc"); 创建了几个对象 2个(池里没有)或1个(池里有了),
     * 3.String s = "a" + "b" + "c" + "d"; 创建了几个对象? 创建了1个对象
     * 4.String s1 = "a"; String s2 = "b"; String s3 = s1 + s2;  s3=="ab"?
     */
    
    public static void main(String[]args)
    {
        /*
         * 1.String池,由于字符串操作很频繁.java针对String对象提供了缓冲池
         * s1首先会在缓冲池里面看一下有没有"abc" 如果没有的.那么把对象创建的引用返回给s1
         * 当s2开始执行.会检查缓冲池里面有没有.如果有的.直接把对象的地址返回给s2 .所以是相等的.。
        String s1 = "abc";
        String s2 = "abc";
        System.out.println(s1 == s2);
        */
        
        /*
        String s1 = "abc";
        String s2 = new String(s1); 
        outcome : false
        s2在堆内存中创建了一个对象(把地址返回来~),并且在堆内存里面的缓冲池里面创建一个"abc"(这个是对象里面的一个拷贝副本)
        做java的日常维护.所以那么这两个地址一比较.就会不相等..
        */
        
        /*
        String s1 = "a"+"b"+"c";
        String s2 ="abc";
        outCome = "true";
        因为java编译器有个合并已知量的功能,在编译阶段"a"+"b"+"c" 合并为"abc"并且保存在缓冲池里面
        所以s2在检测缓冲池里面.检测到已经有了.直接把对象的引用所返回来.那么证明了s1  s2 是同一个地址/所以比较出来为true
        */
        
        /*
        String s1 = new String("abc");
        String s2 = new String("abc");
        这两个里面创建了多少个对象呢?
        解答:  首先会在堆内存中创建一个对象.在检测池里面有没有,没有也在了缓冲池里面创建了一个.做日常的维护
        s2也会在堆内存中创建一个对象.这时候检测到池里面已经有了.所以就不再创建/
        说百了也就是3个..
        一般面试简单的就直接说:2个就可以.
        */
        
        /*
         * String 是一个常量,是不能改变的量
         * 内部实现:
         * StringBuilder sb = new StringBuilder(s1);
         * sb.append(s2);
         * s3 = sb.toString(); //转换回字符串
         * 返回调用方法的都是创建一个对象的
         * 
         */
        String s1 = "a";
        String s2 = "b";
        String s3 = s1 + s2;
        System.out.println(s3=="ab"); //直接返回一个flase
        
    }

}

第二:

package com.javami.kudy.javaapi1.StringStudy;

import java.io.UnsupportedEncodingException;

public class DecodeTest {
    
    /*
     * 解码: 用错误的码再变回来.然后用正确的编码方式就可以
     * 编码错误: 没办法,神仙也救不了
     */
    public static void main(String[]args) throws UnsupportedEncodingException
    {
        String str1 = "中国人";  //使用gb2312编码
        // 使用平台的默认字符集将此 String 编码为 byte 序列,并将结果存储到一个新的 byte 数组中。
        byte[] newbyte = str1.getBytes();
        
        String str2 = new String(newbyte);
        System.out.println(str2);
        
        
        String str3 = new String(newbyte,"iso-8859-1");
        //System.out.println(str3);编码的信息出错
        newbyte = str3.getBytes("iso-8859-1");    
        String str4 = new String(newbyte);
        System.out.println(str4);
        
        byte[]new1 = str1.getBytes("iso-8859-1");
        //一开始编码的信息就出错!因为我的计算机根本就没有这个编码
        String s6 = new String(new1);
        new1 = s6.getBytes("iso-8859-1");
        String st7 = new String(new1);
        System.out.println(st7);
    }
}

第三:

package com.javami.kudy.javaapi1.StringStudy;

public class StringTest {
    /*String 为什么要重写toString()方法呢?
        解答:因为在String如果不重写Object的toString方法.那么直接复用父类的方法.打印出的是对象.
        这显然不是String想要得到的结果
     */
        public static void main(String[]args) 
        {
            String s1 = "kudy";
            System.out.println(s1.charAt(3)); //索引是从零开始\
            String s2 ="abcde";
            String s3 = "aBcddddd";
            System.out.println(s2.compareToIgnoreCase(s3));
            
            String s4 = "abc";
            String s5 = "def";
            System.out.println((s4.concat(s5)).toString());
            
            boolean is = s4.contains(s5);
            System.out.println(is);
            
            String fileName = "Demo.jdk";
            if(fileName.endsWith(".java"))
                    System.out.println("您是java文件");
            
            String s6 = "cnabcdbvklabcjdhfabcdhla";
            int newint = s6.indexOf("abc",0);  //注意:索引是从零开始
            System.out.println(newint);
            
            String s7 = "abc";
            String s8 = new String("abc");
            s8.intern();
            System.out.println(s7 == s8);
            
            String s9 = "cascascacvdfdjkgksd";
            int num = s9.lastIndexOf("k",s9.length()-1);
            System.out.println(num);
            
            String s10 = "abc";
            String s11 = s10.replace("abc","***");
            System.out.println(s11);
            
            String s12 = "hello.java";
            String s13 = s12.replace("java","jdk" );
            System.out.println(s13);
            
            
            /*
             * 把有逗号的内容去掉。
             */
            String s14 = "ab,cd,ef";
            String [] s15 = s14.split(",");
            for(String num1 : s15)
                    System.out.print(num1);
            
            String s16 = "abcbsbdasdas";
            char[] newchar = s16.toCharArray();
            for(char num2 : newchar)
                    System.out.print(num2);
            System.out.println();
            
            /*
             * 但注意中间的是不能去掉的~~
             */
            String s17 = "   abc      def     ";
            String s18 = s17.trim();
            System.out.println(s18);
        }
}

第四:

  1 package com.javami.kudy.javaapi1.StringStudy;
  2 
  3 import java.io.IOException;
  4 
  5 public class StringUtil {
  6     private StringUtil(){} //私有化
  7     
  8     /* 查找子字符串在字符串中出现的位置 例:“ab”在"habjklabljhlabhjdjfla"出现的位置为:1 6  12 
  9      * 思路:
 10      * 1.定义一个StringBuilder容器,用于存储位置,定义一个pos变量记住出现的位置,初始值为0
 11      * 2.定义一个while循环,查找子串出现的位置
 12      * 3.调用indexOf方法,从起始位置开始查找出子串首次出现的位置
 13      * 4.如果pos为-1,说明没找到,应该结束循环
 14      * 5.将位置存入StringBuilder容器,再加一个逗号分隔
 15      * 6.从找到的位置加上子串的长度作为新的起始位置,
 16      * 7.循环结束,将StringBuffer转为String字符串,调用split方法以逗号进行分隔,获得了String数组
 17      * 8.准备一个新的int数组,长度和String数组一样,遍历String数组,将每个元素转为int存入int数组
 18      */
 19     public static int[]findIndexOfSubstr(String str, String substr)
 20     {
 21         StringBuilder sb = new StringBuilder();
 22         int pos = 0;
 23         while(true)
 24         {
 25              pos = str.indexOf(substr,pos);
 26              if(pos ==-1)
 27                  break;
 28              sb.append(pos+",");
 29              pos+=substr.length(); //pos假设找ab 找到1 + 2 等于三.刚好从第三个开始找~
 30         }
 31         if(sb.length() == 0) //容器什么都没有!
 32             return null;  //一个都找不到
 33         String s = sb.toString(); //转换成字符串形式
 34         String[] parts = s.split(",");
 35         int[] arr = new int[parts.length];
 36         for(int i=0; i<parts.length; i++)
 37         {
 38             arr[i] = Integer.parseInt(parts[i]);
 39         }
 40         return arr;
 41     }
 42     
 43     /*
 44      * 设计一个方法,读取键盘输入的一行(只支持英文字母)
 45      * 提示:System.in.read()读取键盘上的一个字符
 46      * 思路: 
 47      * 1.定义一个容器StringBuilder容器
 48      * 2.定义一个while循环,循环读取键盘.
 49      * 3.如果读到回车或者\n 就跳出循环
 50      * 4.存入StringBuilfer容器中
 51      * 5.循环结束,返回一个toString转换为字符串
 52      */
 53         public static String readLine() throws IOException
 54         {
 55             StringBuilder sb = new StringBuilder();
 56             while(true)
 57             {
 58                 int ch = System.in.read();
 59                 if(ch == '\r')  //如果回车 跳出去
 60                     continue;
 61                 if(ch == '\n')  //等上面的执行完毕.再来
 62                     break;
 63                 sb.append((char)ch);
 64             }
 65             return sb.toString(); //转换成字符串
 66         }
 67         
 68         /*
 69          * *将给定的字节数组截取一部分,进行解码,要求输出完整的汉字,例如:"abc中国人"截取6个 输出的是abc中
 70          * 思路:
 71          *     1.遍历数组被截取的部分,
 72          * 2.判断正负数,统计负数个数为count
 73          * 3.判断count的奇偶,奇数减去1,偶数不变
 74          * 4.解码
 75          * 汉字是占了2个字节?我们怎么判断它是汉字呢?
 76          * 汉字的第一位字节保证是负数!第二个是正数
 77          * 
 78          */
 79         public static String decode(byte[]buf, int len)
 80         {
 81             int count = 0;
 82             for(int i=0; i<buf.length;i++)
 83                 if(buf[i]<0)
 84                         count++; //如果第一个字节是负数的.是代表汉字马上来到.咱们+1
 85             if(count % 2 == 1)
 86                 len--;
 87             return new String(buf,0,len);
 88             /*程序流程图: 咱们输入一个buf   len = 5
 89              * for 执行5次
 90              * 因为一个汉字是占了2个字节.而第一个字节保证是负数
 91              * 如果 buf[i]里面的是负数的 count +1 = 1
 92              * 如果   % 2  等于1代表的是:   咱们len 传递进来的就减去一个字节.
 93              * 
 94              */
 95         }
 96         
 97         public static String decodeBYGBK(byte[]buf,int len)
 98         {
 99             boolean b = false; 
100             for(int i=0; i<buf.length; i++)
101                 if(b)
102                     b = false;
103                 else if(buf[i]<0)
104                     b = true;
105             if(b)
106                 len --;
107             return new String(buf,0,len);
108             
109         }
110         
111         /*
112          * 查找一个字符串出现次数最多的字符     abvjdabahabballfja   出现次数最多的为:a  6
113          * 思路:
114          * 1.调用toCharArray字符串把字符串转换成字符数组
115          * 2.定义max,用于记住出现最多字符的次数,定义一个maxChar记住出现最多的字符
116          * 3.定义一个循环,每次循环都统计一个字符出现最多的次数,每次让次数和max比.谁最大就换,结束条件。当长度的数组
117          * 为零
118          * 4.定义一个count,记住本次统计字符的次数
119          * 5.循环遍历数组,统计第一个字符出现的次数
120          * 6.让次数和max比,如果max大,让max记住它的次数,让maxchar记住当前的字符
121          * 7.将当前的字符从数组中删除
122          * ------
123          * 将此字符串转换为一个新的字符数组。
124          */
125 
126         public static char searchMaxChar(String str)
127         {
128             char[] buf = str.toCharArray();
129             int max = 0;
130             char maxChar = 0;
131             while(buf.length>0)
132             {
133                 int count = 0; //个数等于0
134                 char firstChar = buf[0];
135                 for(char c : buf)
136                     if(c ==firstChar)
137                         count++;
138                 if(count>max) //max 已经是默认记住上一个的值!
139                 {
140                     max = count;
141                     maxChar = firstChar; //如果你是最多的就让给你~~
142                 }
143                 //把当前的字符删除!
144                 buf = deleteChar(buf,firstChar,count);
145             }
146             return maxChar;
147         }
148 
149         private static char[] deleteChar(char[] buf, char firstChar, int count)
150         {
151             char[]arr = new char[buf.length-count];
152             int pos = 0;
153             for(int i=0; i<buf.length; i++)
154             {
155                 if(buf[i]==firstChar)
156                         continue;
157                 arr[pos++] = buf[i];
158             }
159             return arr;
160         }
161         /* 查找两个字符串中的最大子串  jflwertyakjfa;l    fjdlkwertyjf;ajf 最大子串:werty
162          * 1.判断出两个字符串的长短,找出较长的和较短的
163          * 2.循环遍历较短的字符串的所有子串,由长到短遍历
164          *         定义一个循环,每次遍历一种长度的子串,将i作为长度,i的取值: length~1
165          *         定义一个内层循环,具体遍历某一种长度的子串,j做为子串的开始位置, j取值:0~length-i
166          *         截取子串,substring  起始位置:j  结束位置:j+i
167          * 3.每次变量,都判断子串是否为较长的字符串的子串,如果是,直接返回
168          * 4.循环结束,依然没有返回,说明没有相同子串,返回null
169          */
170         public static String searchMaxSubStr(String s1, String s2) 
171         {
172             String longStr = s1.length() > s2.length() ? s1 : s2;
173             String shortStr = s1.length() > s2.length() ? s2 : s1; 
174             for(int i=shortStr.length(); i>0; i--)
175             {
176                 for(int j=0;j<shortStr.length()-i+1;j++)
177                 {
178                     String sub = shortStr.substring(j, j+i); //例如: abcd 放到sub里面去
179                     //abcd abc ab  a 和它里面的做一个对比  
180                     //当且仅当此字符串包含指定的 char 值序列时,返回 true。 
181                     if(longStr.contains(sub)) 
182                         //判断长的字符串里面是否包含这个
183                         return sub; //如果包含直接返回.没有包含
184                 }
185             }
186             return null;
187         }
188 }
189 
190 
191 ----------------------
192 
193 package com.javami.kudy.javaapi1.StringStudy;
194 
195 public class StringUtilTest {
196         public static void main(String[]args) throws Exception
197         {
198             /*
199             String str = "dsdcvcvxvczxbedfaacff";
200             String substr = "y";
201             //遍历a 出现的位置
202             int[]arr =  StringUtil.findIndexOfSubstr(str, substr);
203             if(arr ==null)
204             {
205                 System.out.println("找不到!");
206                 return ;
207             }
208             for(int num : arr)
209             {
210                     System.out.print(num+" ");
211             }
212             System.out.println();
213             
214             */
215             /*
216              * 再输入byte的时候就结束,不断的去读
217 
218             while(true)
219             {
220                 String str2 = StringUtil.readLine();
221                 if("bye".equals(str2))
222                     break;
223                 System.out.println(str2);
224             }
225             System.out.println("程序结束");    
226             */
227             byte[] buf = "abc中国人".getBytes();
228             //String s3 = StringUtil.decode(buf, 3);
229             String s3 = StringUtil.decodeBYGBK(buf, 5);
230             System.out.println(s3);
231             
232             char maxChar = StringUtil.searchMaxChar("dasfasdfaaaaaaaasfgdagfafgsad");
233             System.out.println(maxChar);
234             
235             String s33 = "jflwertyakjfa;l";
236             String s44 = "fjdlkwertyjf;ajf";
237             String s55 =StringUtil.searchMaxSubStr(s33,s44);
238             System.out.print(s55);
239         }
240 
241 }
posted @ 2012-08-07 01:07 、小细 阅读(200) | 评论 (0)编辑 收藏
     摘要: 1 Java的环境配置 day01 2 3 1. 环境配置有如下的三种方法: 4 a) 我的电脑属性: 从path 环境中配置 5 b) 利用临时的变量设置: set path = java的所在路径\bin%d% 6 c) 定义批处理文件 : 设置步骤如下: 7 a) set path = %cd%\H:\java\jdk1....  阅读全文
posted @ 2012-08-07 01:04 、小细 阅读(126) | 评论 (0)编辑 收藏

面试题:请说说抽象类和接口的区别


抽象类,使用abstract关键字修饰的类为抽象类,一般来说,含有抽象方法的类就需要定义为抽象类,但是抽象类不一定都有抽象方法,比如,在GUI当中,对于事件处理提供了很多监听器口里里面方法都是抽象的,每次进行事件处理时,都需要实现监听器接口,哪怕只处理一个简单的动作,也需要实现接口所有的方法,这样很麻烦,而且显得代码很臃肿,Java提供了适配器,适配器就是自己实现了监听器接口,但是所有的方法都是空实现,以后再用到监听器时,我们可以继承适配器,实现我们需要的方法就可以了,这样就很方便。像这样的适配器只是给调用者提供一个方便,一定不希望别人直接创建实例来使用,所以有必要将它定义为abstract抽象的。

接口,接口是一种特殊的抽象类,接口中所有的方法都是抽象的,通常来讲,我们使用接口作为一种协议,起到各模块之间的衔接作用。由于Java中只支持单继承,不支持多继承,但是可以实现多个接口,原因在于接口中所有的方法都抽象,子类继承哪个都无所谓,我们让一个类实现多个接口,就可以做到将一个子类对象当做多种父类类型来使用,所以我认为定义接口就是为了更好地实现多态,因为多态就是把子类当做父类来用.

 

posted @ 2012-08-07 01:01 、小细 阅读(57) | 评论 (0)编辑 收藏
 1 /*
 2     子类对象的实例化过程
 3     我们可以用一个类的变量记住它的子类的子类的实例.这时如果调用子类中的方法,只需要强制转换子类就可以
 4     没必要非得强制转换子类的子类.
 5     instanceof关键字:也可以判断子类实例也属于父类的类型.
 6 */
 7 
 8 class A
 9 {
10     A()
11     {
12         //如果程序没有写构造方法的/java会默认给它添加构造方法!
13     }
14     public void a()
15     {
16             System.out.println("a() in A");
17     }
18 }
19 
20 class B extends A
21 {
22     B()
23     {
24         super(); //默认调用父类的无参的构造方法!
25     }
26     public void a()
27     {
28             System.out.println("a()in B");
29     }
30 
31     public void b()
32     {
33             System.out.println("b()in B");
34     }
35 
36 }
37 
38 class C extends B
39 {
40     public void a()
41     {
42             System.out.println("a()in C");
43     }
44     public void b()
45     {
46             System.out.println("b()in C");
47     }
48     public void c()
49     {
50             System.out.println("C()int C");
51     }
52 }
53 class Demo 
54 {
55     public static void main(String[] args) 
56     {
57         A a = new C();
58         if(a instanceof C)
59         {
60             C c =(C)a;
61             c.c();
62         }
63         if(a instanceof B)
64         {
65             B b = (B)a;
66             b.b();
67         }
68     }
69 }
/*
    继承的细节
    1.子类不会继承与父类的私有的成员
    2.构造函数是不会被继承.
    3.只支持单继承,可以多重继承.

    ------------------
    1.以后在设计一个类的时候,父类一定要加上一个不带参数的super,否则子类实例化的时候会报错!
    为什么有这样一个机制:
    解答:别人来继承与这样一个类,一定也需要这个子类具有父类的方法.但是别人并不知道在构造函数里面做了一些特别才能实现这个
    的功能.所以java就规定子类实例化的过程中.一定会默认调用与父类的super()的构造方法.如果你在父类中没有定义一个无参的.
    那么在实例化的过程中是会容易出错的.
*/

class Person
{
    private String name ;
    public Person(String name)
    {
        this.name = name;
    }
    public  Person()
    {
            //咱们加一个无参的构造方法!
    }
    public    void eat()
    {
            System.out.println("是人都要吃东西!");
    }

}

class Student extends Person
{    
    public Student()
    {
        //不带参数的构造函数!
        super(); //默认为这个?  但是有这个父类的构造函数吗?显然没有对吧.。
    }
    public void eat()
    {
            System.out.println("抽一根");
            super.eat();
    }
}
class Demo 
{
    public static void main(String[] args) 
    {
        Student st = new Student();
        st.eat();
    }
}
/*
    子类的实例化过程:子类在创建做了什么事情呢?
    解答:在创建子类的时候,会调用子类的构造函数,在子类构造函数的第一行会默认调用父类的构造函数
                在子类构造函数中如果没有显式地调用父类的构造函数.它会自动的调用父类的无参的构造函数(在这个问题上你要注意)
            我们可以在构造函数中使用this(实参)来调用自己的带参数的构造方法
            还可以用super(实参)去调用父类型的带了参数的构造方法/
            但要注意:this 与super()只能出现一次.  并且在第一行.
            如果一个构造函数调用了this ,那么就不能从第二个语句使用super()
*/


class Person
{
    private String name ;
    public Person()
    {
            System.out.println("无参的Person()被调用啦!");
    }
    public Person(String name )
    {
        this();
        System.out.println("有参的Person()被调用啦!");
        this.name = name;
    }

}

class Student extends Person
{
    private String name;
    public Student()
    {
            super("kudy");
            System.out.println("无参的Student()被调用啦~");
    }
    public Student(String name)
    {
            this();  //与super()不能同时出现
            System.out.println("有参的Student()被调用啦~");
    }

}

class Demo 
{
    public static void main(String[] args) 
    {
        new Student("abc");
    }
}


/*

输出的结构为:
--------------------------------
无参的Person()被调用啦!
有参的Person()被调用啦!
无参的Student()被调用啦~
有参的Student()被调用啦~
*/
/*
    关于多态:
                不变应万变
*/

abstract class Person
{
    public abstract void eat();
}

class Chinese extends Person
{
    public void eat()
    {
            System.out.println("中国的人还是广东人最好啦!");
    }
}
class Shop
{
    public void shopping(Person p )
    {
            System.out.println("咱们去买好东西吃!");
            p.eat();
    }
}
class Demo
{
    public static void main(String[] args) 
    {
        Shop shop = new Shop();
        shop.shopping(new Chinese());

    }
}
/*
    子类实例化的面试题!
    A1 B2 B1
*/

class A
{
    String name = "张三";
    public A()
    {
            System.out.println("A1");  //A1
    }
    public A(String name)
    {
        this();    
        System.out.println("A2");
    }
}

class B extends A
{
    String name = "王五";
    public B()
    { 
            this("张");  //如果有了this 就是默认没了super()
            System.out.println("B1");
    }
    public B(String name)
    {
    //    super();
        System.out.println("B2"); //B2
    }
}

class Demo 
{
    public static void main(String[] args) 
    {
        new B();
    }
}
/*
    覆盖父类的方法:
    子类当中覆盖父类的方法必须要和父类具有相同的方法名,具有相同的参数类型,具有相同的返回值 返回值类型一定要和
    子类的保持一直.这样就是方法的重写
    子类的方法的权限不能比父类有更严格的访问权限,因为我们经常要把子类当做父类来使用.
    子类去访问父类的方法时,会比较一下子类的访问权限.如果权限比父类小.那么就挂啦

    多态: 把子类当做父类来使用,针对父类进行方法的调用.传入不同的子类.执行的结构是一样的.
    除非父类被子类这个哥们重写啦方法~
*/
class Person
{
    public void run()
    {
            System.out.println("run() in Person");
    }
    public Person getInstance()
    {
            return new Person();
    }
}

class Student extends Person
{
    public void run()
    {
            System.out.println("happy");
            super.run(); //调用了父类的run方法!
    }
    public  Student getInstance() //权限不应该比父类的要小.  如果权限要比父类的小.那么就OH.Sorry
    {
        return new Student();
    }
}
class Demo 
{
    public static void main(String[] args) 
    {
        Student stu = new Student();
        stu.run();
        run(stu);
    }
    //实现了多态!
    public static void run(Person p )
    {
         p = p.getInstance();
        p.run(); //实现了多态
    }
}
/*
final 关键字:最终的!终态的
1.被fina修饰的属性为常量,是不能被更改的.也就是说:值是不能被改变
2.final所修饰的方法不能被重写,也就是说不能被子类所覆盖
3.final修饰所修饰的类是不能被继承的!

一般fina的用法:public static fina String NAME = "kudy"; 
为什么它一般是和static一起的呢?
解答:
既然一个属性都不能被修改啦.是一个常量啦.咱们可以把他定义一个static的.在类出生的时候.它也会跟着出生.
方便.
*/
/*
final class Person
{
    //被final所修饰的类是不能被继承的!
}
*/
class Person
{
    public static final int NUM = 19 ;//给我修饰的常量是不能被修改的!
    public final void show()
    {
            System.out.println("给我修饰的方法都是不能被重写!");
    }
}
class Student extends Person
{
    /*
    public void show()
    {
            System.out.println("真的是不能被重写噢!");
    }
    */
    public void run (int num)
    {
        //先比较后自加!
        System.out.println(++num);
        System.out.println(num++); 
        //? 为多少呢?  20  //因为第一次自加1  后来第二次的时候。先输出值它自己再加1
    }
}
class  Demo
{
    public static void main(String[] args) 
    {
        Student stu = new Student();
        stu.run(stu.NUM);
    }
}
/*
    设计模式!组合
    组合:当一个对象在运作的过程中必须要用到另外一个对象的时候,然而又不是构成继承的关系的!
*/
class Guo
{
    public void heat()
    {
            System.out.println("已经自动的加热啦~");
    }
}
class Chef
{
    //吃食品的时候一定要把它加热嘛~~
    Guo guo;
    Chef(Guo guo)
    {
        this.guo = guo;
    }
    public void cook()
    {
        guo.heat();
    }
}
class Demo 
{
    public static void main(String[] args) 
    {
        Chef chef = new Chef(new Guo());
        chef.cook();
    }
}
/*
    这样也是一个简单的组合!
*/
class Card
{
    public void spend()
    {
            System.out.println("一不小心就花了600RMB");
    }
}

class Person
{
    Card card ;
    public Person(Card card)
    {
        this.card = card;
    }
}

class Chinese extends Person
{
    public Chinese(Card card)
    {
        super(card);
    }
}

class Shop
{
    public void Shopping(Person p )
    {
        System.out.println("happy完毕!");
        p.card.spend();
    }
}

class  Demo
{
    public static void main(String[] args) 
    {
        Shop shop = new Shop();
        shop.Shopping(new Chinese(new Card()));
    }
}
/*
    抽象类:

1.没有方法体必须要声明为abstract抽象方法
2.含有抽象方法的类一定是抽象类
3.抽象类的定义:用abstract修饰的类叫做抽象类
4.抽象类是不能被实例化的(也就是说不能创建对象!);
5.可以用一个抽象类来继承一个抽象类.会继承所有的方法
6.如果用一个类来继承抽象类,那么必须要实现抽象类里面所有的方法
7.抽象类的访问权限没有什么特殊之处.主要是看修饰符!
8.抽象类里面不一定有抽象方法.但是包含有抽象方法一定是抽象类
*/

abstract class A
{
    abstract void a();//抽象方法!
    public void run()
    {
            System.out.println("A run()");
    }
}

abstract class B extends A
{
    abstract void b();
}

class C extends B
{
    //必须要把它所继承的所有的抽象方法实现!
    public void a()
    {
            System.out.println("A.class");
    }
    public void b()
    {
            System.out.println("B.class"); //实现B
    }
}
class  Demo
{
    public static void main(String[] args) 
    {
        A a = new C();
        if(a instanceof C)
        {
            C c = (C)a;
            c.a();
            c.b();
            c.run();
        }
    }
}
/*
    如果有多个类具有相同的方法声明,但是方法的实现细节不一样.
    我们就需要定义抽象类. 抽象父类

    里面可用到的新学习的知识  : 组合哦
*/

abstract class Person
{
    public abstract void eat();
    public void run()
    {
            System.out.println("吃完饭跑步是最好的!");
    }
}

class Man extends Person
{
    public void eat()
    {
            System.out.println("大口大口的吃!");
    }
}

class WoMan extends Person
{
    public void eat()
    {
            System.out.println("小口小口的吃!");
    }
}

class Begin
{
    private Person p;
    public  Begin(Person p)
    {
        this.p = p;
    }
    public void getBegin()
    {
        p.eat();
        p.run();
    }
}
class Demo 
{
    public static void main(String[] args) 
    {
        Begin begin = new Begin(new Man());
        begin.getBegin();
    }
}
//甲写的代码

class C
{
    public void run(A a)
    {
        a.c();
    }
}
abstract class A
{
    abstract void a();
    abstract void b();
    abstract void c();  //我这里有一个C是被子类所重写啦!
    abstract void d();
    abstract void e();
    abstract void f();
}

abstract class AbstractB extends A  //需要我都可以实现!但是我用到这种方式!
{
    public void a()
    {

    }
    public void b()
    {

    }
    public void c() //哥们.你也有啊!是不是OH啦
    {

    }
    public void d()
    {

    }
    public void e()
    {

    }
    public void f()
    {

    }
}
class B extends A
{
    public void a()
    {

    }
    public void b()
    {

    }
    public void c() //哥们.你也有啊!是不是OH啦
    {
            System.out.println("c() in B");
    }
    public void d()
    {

    }
    public void e()
    {

    }
    public void f()
    {

    }
}

class  Demo
{
    public static void main(String[] args) 
    {
        /*
        C c = new C();
        c.run(new B());
        */
        C  c = new C();
        //为什么抽象的都可以new呢?但要注意.我这个是匿名内部类
        c.run(new AbstractB(){
            public void c()
            {
                    System.out.println(" AbstractB in C");
            }
        }
            );
    }
}
/*
    模板方法的设计模式:
    定义一个抽象类作为模板,将具体做事情方法定义出来,但是不实现
    2.对外提供一个共有的方法作为接口,规定做事情的顺序/这个方法应该为final 避免了让子类重写
    子类继承模板,实现所有的抽象方法()
*/

abstract class AbatractPrint
{
    abstract void opend();
    abstract void print();
    abstract void close();

    //定义成终态的.避免了子类所修改!
    public final void run()
    {
        this.opend();
        print();
        close();  //调用方法!
    }
}

class StringPrint extends AbatractPrint
{
    private String data;
    StringPrint(String data)
    {
        this.data = data;
    }
    public void opend()
    {
            System.out.print("<<");
    }
    public void print()
    {
            System.out.print(data);
    }
    public void close()
    {
            System.out.print(">>");
    }
}
class Demo 
{
    public static void main(String[] args) 
    {
        AbatractPrint abatractPrint = new StringPrint("kudy");
        abatractPrint.run();
        //使用匿名内部类做一下这道题目!
        //我现在不是为了抽象类创建对象.而是为了匿名子类!  //也多多态的一种形式!
        //匿名内部类重写了父类的方法!并且调用一把run();
        new AbatractPrint(){
                public void opend()
        {
                System.out.print("<<");
        }
        public void print()
        {
                System.out.print("show");
        }
        public void close()
        {
                System.out.print(">>");
        }
        }.run();
    }
}
//定义抽象类作为接口,实现个模块之间的解耦
/*
        首先第一种方法的:  显示就是三个人不能同时分工协作啦~~

        咱们传入的时候要注意:  我们传入的是子类.  父类型的引用指向了子类型的对象。
*/
//定义一个抽象的数据产生器!
import java.io.*;
abstract class Generator
{
    abstract String getData();
}

//定义一个抽象的数据处理器
abstract class  DataHandler
{
    abstract String    handleData(Generator generator);
}

//甲负责写数据产生器
class OneGenerator extends Generator
{
    public String getData()
    {
            return "hello";  //产生了一个数据!
    }
}

//乙所负责写的数据处理代码
class OneDataHandler extends DataHandler
{
    public String  handleData(Generator generator)
    {
        String data = generator.getData();
        return  "~~"+data+"~~"; 
    }
}

//数据产生器!
class TwoGenerator extends Generator
{
    public String getData()
    {
        return "小细加油";
    }
}

//数据处理器!
class TwoDataHandler extends DataHandler
{
    public String     handleData(Generator generator)
    {
        String data = generator.getData();
        return "~~~"+data+"~~~";
    }
}


/*
    数据显示!
*/
class Demo 
{
    public static void main(String[] args) throws Exception
    {
        BufferedReader br 
                            = new BufferedReader(new InputStreamReader(System.in));
        /*
        DataHandler data = new OneDataHandler();
        Generator gen = new OneGenerator();
        */
        //通过读取键盘获得用户使用的数据产生器名字
        System.out.println("请输入您使用的数据产生器:");
        String generatorClassName = br.readLine();
        //根据类名反射出类
        //Class class -->new Class()对象 --》class.Class
        //1-1根据类名反射出类!
        Class generatorClazz = Class.forName(generatorClassName);  ////又因为返回的是object 类型/所以我们要强制转换.否则没有办法赋值。
        //根据类创建实例对象(数据产生器)
         Generator  generator=( Generator) generatorClazz.newInstance(); //类创建对象。并且是父类型的引用指向子类型的对象。

         //2.通过反射获得数据的处理器对象
         System.out.println("请输入您要使用的数据处理器:");
         String dataHandlerClassName = br.readLine();
         Class dataHandlerClazz = Class.forName(dataHandlerClassName);
         DataHandler dataHandler = (DataHandler)dataHandlerClazz.newInstance();
        String data = dataHandler.handleData(generator);
        System.out.println(data);
    }
}
posted @ 2012-08-07 00:59 、小细 阅读(60) | 评论 (0)编辑 收藏
/*
    内部类:
1.在类中定义的类我们称之为内部类,它是外部类的一个成员。
2.内部类可以直接访问外部类的成员,但是外部类不能直接的去调用外部类的成员、
其实内部类调用外部类的成员的时候.其实是使用到了:类名.this.变量名 来访问外部类的成员。
3.在内部类中的方法可以使用this引用调用这个方法的内部类对象.


*/
class Outer
{
    String name = "张三";
    public void run()
    {
        System.out.println("Outer is Running");
    }
    public void show()
    {
        System.out.println("My name is Outer");
        System.out.println(new Inner().age);
    }
    class Inner
    {
            int age = 19;
            public void run()
            {
                System.out.println("Inner is Running");
            }

            public void eat()
            {
                this.run();  //this.代表方法所调用的对象.它的对象是inner 所以输出的是inner
                show();  //因为创建内部类的时候.外部类的对象已经创建了.  如果虚拟机在内部类中找不到.它会到外部类去找这个show()对象.
                System.out.println(Outer.this.name); //其实同等于:Outer.this.name  //类名.name
                System.out.println("Nnner is Eat");
            }
    }
}
class Demo 
{
    public static void main(String[] args) 
    {
        Outer.Inner  inner = new Outer().new Inner();  //类型要一致!
        inner.run();
        inner.eat();

    }
}

/*
    可以在方法中定义内部类?
    System.out.println(age);为什么会访问不了呢.编译出错/
    其实:当我们在外部类调用A对象的时候.run()方法由于age是存储在栈内存的临时变量中的. 当我们对象调用完毕过后呢.
    有可能是会被释放调的.而当你再次调用的时候 age 的时候呢.由于虚拟机可能会被释放.所以调用不了.
    那么:虚拟机认为你这样做是编译错误的!
*/

class A
{
    String name = "小细"    ;
    public void run()
    {    
        int age = 19;
        class B
        {
            public void run()
            {
                String name = "王五";
                System.out.println("my name is B");
                //System.out.println(age);
                System.out.println(A.this.name);  //通过类名.this.属性名访问外部类的属性.
            }
        }
        new B().run();
    }
}

class Demo 
{
    public static void main(String[] args) 
    {
        A a = new A();
        a.run();
    }
}

/*
    匿名内部类:

*/
class Fruit
{
    public void qupi()
    {

    }
}

class Person
{
    public void eat(Fruit f)
    {
        f.qupi();
        System.out.println("吃完啦!!");
    }
}

class Demo
{
    public static void main(String[] args) 
    {
        Person p = new Person();
        p.eat(new Fruit(){
            public void qupi()
            {
                System.out.println("Apple把皮弄开!");
            }
        }
            );
    }
}

/*
    static修饰的静态内部类:

    1.静态的内部类可以声明非静态的属性和方法.  但是静态的内部类是不能访问外部类非静态的方法.因为外部类的属性需要创建对象才能调用.
    你内部类是不需要创建对象的.所以调用不了。

    2.静态的内部类不能访问非静态的属性.
*/

class Outer
{
    static  String name = "kudy";
    String ID = "888";
    static class Inner
    {
            int age = 19;
            public void run()
            {
                    System.out.println(age);
                    System.out.println("Inner is happy");
                    System.out.println(Outer.name); //因为是不需要创建对象的.所以可以使用Outer.name访问外部的静态的方法。
                //    System.out.println(Outer.ID);
            }
    }
}

class Demo 
{
    public static void main(String[] args) 
    {
        Outer.Inner inner =  new  Outer.Inner();  //静态的内部类一定要静态的去创建!
        //System.out.println(inner.age);
        inner.run();

    }
}
/*
    类的继承
1.使用extends关键字来声明类的关系
2.子类会自动继承父类的属性与方法
*/

class Person
{
    String name ;
    public void run()
    {
        System.out.println("Person is Running");
    }
}

class Man extends Person
{
    public void toLike()
    {
        System.out.println(name +"运动"); //默认会添加上this的
    }
}
class Demo 
{
    public static void main(String[] args) 
    {
        Man man = new Man();
        man.name = "小细";
        man.run();
        man.toLike();
    }
}
    

/*
    类的继承是为了实现代码的复用性,如果有多个类具有相同的方法.我们应该尽量把她抽出一个类来
*/
class Person
{
    String name ;
    int age;
    public void eat()
    {
        System.out.println(name+"吃饭"+",年龄为:"+age);  //this.name this.age
    }
    public void run()
    {
        System.out.println("需要运动");
    }
}

class Student extends Person
{
    public void eat()
    {
        System.out.println("吃一口饭");
        super.eat();  //调用父类的方法、。
        System.out.println("看一下作业");
    }
}
class Teacher extends Person
{
    public void eat()
    {
        System.out.println("抽一根");
        super.eat();
        System.out.println("再来一根");
    }
}
class Demo 
{
    public static void main(String[] args) 
    {
        Student student = new Student();
        student.name = "小细";
        student.age = 19;
        student.eat();
        student.run();

    }
}
/*
父类型的引用指向子类型的对象.也就是想上类型转换.不需要强制转换
强制转换的要求:  父类型的引用指向子类型的对象。
3.把父类当做子类来使用是不行的,因为子类有的.父类型不一定有
4.当做子类当做父类来用时,只能使用父类型所拥有的方法。
如果调用子类拥有的方法.编译器会报错!所以需要强制转换.但在强制转换的前提下我们要知道父类型的引用是否是指向了子类型的对象
强制转换之前需要判断一下.
注意:
        1.当你父类型的引用指向子类型的对象的时候.你必须要清楚的就是:你访问的属性是会是父类的.而不是子类的.
        因为java在属性方法是做了静态的绑定.谁是我的类型.我就去谁的类型去找.而方法就刚好相反.
        方法就是:谁指向谁.我就调用谁的方法.。  因为是做了动态的绑定。
*/

class Typist
{
    String name = "小细";
    public void type()
    {
        System.out.println("typeing");
    }
}

class Coder extends Typist
{
    String name = "王五";
    public void type()
    {
        System.out.println("tepeing slowly!!!");
    }
    public void code()
    {
        System.out.println("Codeing");
    }
}
class Demo 
{
    public static void main(String[] args) 
    {
        //向上类型转换: 父类型的引用指向子类型的对象.
        Typist typist = new Coder();
        //typist.type();  因为你是指向了子类型的引用.所以java做了动态绑定.也就是说你绑定了一个子类型的方法。
        System.out.println(typist.name); 
        /*
            为什么输出小细呢.因为java在检查的时候.属性是不做动态绑定的.也就是说.类型是谁.他就会找类型里面的属性.
        */
        /*
            Code code = new Typist();
            子类型的引用不能指向父类的对象.因为子类有的.父类型不一定有.
        */
        Coder coder;
        if(typist instanceof Coder)  //父类型的引用指向子类型的对象才可以抢走转换!
        {
             coder = (Coder)typist; //强制转换成子类
             System.out.println(coder.name);
        }
    
        

    }
}

/*
    因为java的属性在父类型的引用指向子类型的情况是做了静态的绑定的.所以我们可以这么做!
*/

class Person
{
    private String name = "无名氏";

    public String getName()
    {
        return name;
    }
    public void eat()
    {
        System.out.println("eating");
    }
}
class A extends Person
{
        private String name = "小细";
        public String getName()
        {
            return name;
        }
}
class B extends Person
{
        String name = "kudy";
}
class Demo
{
    public static void main(String[] args) 
    {
        Person p = new A();
        /*
            因为java的父类型的引用指向子类型的对象的时候.方法使用了动态.而属性只使用了静态.也就是说:类型是那个.属性就是从
            那里去找
        */
        System.out.println(p.getName());//这样就是调用了子类型的属性啦~~
    }
}

/*
    什么情况下使用子类当做父类来使用
    匿名内部类:new一个父类对象,后面跟一个花括号,这时不需要创建父类的实例

*/

class Person
{
 String name = "无名氏";
    public void eat()
    {
        //每个人的爱好不同!
    }
}
class    Restaurant
{
    public void run(Person p)
    {
        p.eat();
    }
}


class Chinese extends Person
{

    public void eat()
    {
        String name = "中国人";  //在方法里面是动态调用的哦。
        System.out.println(name+"我是拿筷子吃的!");
    }
}

class American extends Person
{

    public void eat()
    {
        String name = "美国人";
        System.out.println(name+"我只吃汉堡包!");
    }
}
class Demo 
{
    public static void main(String[] args) 
    {
        Restaurant r = new Restaurant();
        //r.run(new American());
        r.run(new Chinese());

/*
内部类:
        class JB extends Person
        {
            public void eat()
            {
                System.out.println("我是吃垃圾的!");
            }
        }
        r.run(new JB());
*/
    r.run(getIndia());
    }
    static  Person getIndia()
    {
        String name = "印度菜";
        Person p  = new Person(){  //我创建了一个子类.子类里面有eat方法重写啦.之后呢.再把这个重写好的对象返回来.也就是说:父类型的引用指向子类型的对象
        public void eat()
            {
                System.out.println(this.name+"印度菜");
            }
        };
        return p;
    }
}

class A
{
    String name = "小三";
    public String getName()
    {
        return name;
    }
    public void run()
    {
        System.out.println(name);
    }
}

class B extends A
{
    private String name = "小四";
    public String getName()
    {
        return name;
    }
    public void run()
    {
        System.out.println(name);
    }
    public void show()
    {
        System.out.println("我是子类!");
    }
}

class Demo 
{
    public static void main(String[] args) 
    {
        A a = new B();  //父类型的引用指向子类型的对象. 就可以使用子类型与父类型所共同拥有的方法.但是子类出来的就不行。
    //    a.show();
    /*
    System.out.println(a.name);

    如果这样写出来是小三,而不是小四,但是在方法里面输出来的就是小四.因为她的属性在方法里面运行啦.所以是动态的.
    而你单独如果想输出它的属性的话,它是根据了静态绑定来进行操作.也就是输出了类型里面属性的内容!

    那方法就是: 给所有的变量私有化.给他开一个public方法.返回属性!!因为方法是可以转换为动态的.

    有的人可能会问?不相同可以吗? 如果不相同的话.前面已经说过: 就是子类型所特有的.你父类型是不可以调用.除非需要强制转换!
    */
    String name = a.getName(); //这时候方法已经给重写
    System.out.println(name); //输出的会是小四
    }
}

/*
    对象的比较:
        对象的比较不能使用 == 这样比较的是比较地址.  应该用equals方法

        因为所有的类都是默认的继承与Object!  我们可以重写它里面的equals比较方法。
*/

class Person
{
    private String name ;
    private int age ;
    public Person(String name ,int age)
    {
        this.name = name ;
        this.age = age ;
    }
    
    @Override  //告诉编译器我重写父类型的方法!  大写的O
    //重写父类的方法!
    public boolean equals(Object obj)
    {
        if(this == obj)
            return true;
        if(obj instanceof  Person)      //如果你父类型的引用是指向了子类型的对象的.那么就判断.
        {
            //因为是按照了父类型的引用是指向了子类型的对象.首先我们要判断一下.强制类型转换.要不然我们是调用不了子类型的内容
            Person p =(Person)obj;

            if(this.name.equals(p.name)&&this.age == age)
                return true;
        }
        return false;
    }
}
class Demo 
{
    public static void main(String[] args) 
    {
    
        Person p1 = new Person("张三",19);  //p1就是当前对象!
        Person p2 = new Person("张三",19);
        System.out.println(p1.equals(p2));
        


    }
}
class Person
{
    String name ;
    public void eat()
    {
    }
}

class Restaurant
{
    public void show(Person p)
    {
        p.eat();
    }
}
class Chinese extends Person
{
    String name = "中国人";
    public void eat()
    {
        System.out.println(name+"我吃中国菜!");
    }
}

class Test 
{
    public static void main(String[] args) 
    {
        Restaurant r = new Restaurant();
        r.show(new Chinese());

        /*
            匿名内部类的第一种用法!
        */
        r.show(new Person(){
            public void eat()
            {
                System.out.println("日本人吃日本菜!");
            }
        }
        );
        r.show(getUSA());
    }

    public static Person getUSA()
    {
        Person p = new Person(){
            public void eat()
            {
                String name  = "美国人";
                System.out.println(name+"吃美国菜!");
            }
        };
        return p;
    }
}


使用Java的文档注释

文档注释以“/**”开始,以“*/”标志结束,相应的信息和批注所对应的位置很重要! 类的说明应在类定义之前,方法的说明应在方法的定义之前。

批注参数来标记一些特殊的属性及其相应的说明 。
@author<作者姓名>
@version<版本信息>
@param<参数名称><参数说明>
@return<返回值说明>

生成文档的命令
javadoc -d Engineer -version -author Engineer.java


心得:
我要向前冲,想前冲。

posted @ 2012-08-07 00:56 、小细 阅读(58) | 评论 (0)编辑 收藏

一.构造函数的定义与作用

1.函数的名次与类同名
2.没有返回值类型
3.不能使用retrun 关键字来返回一个值

注意》》:没有返回值类型声明不等同于“void”,void也是一种返回值的声明(如果写上了void,那就是一个普通的方法啦!)

二.构造函数的具体应用

构造函数可以被重载

1.构造函数也一般的函数一样,都是可以被重载的.但是参数类型要不一致.而且构造函数是没有返回值

构造函数如果被调用?

2.使用new关键字来创建对象的时候,会自动的调用一个类的构造函数.也可以在一个类中利用this();来调用其他的构造函数!
但是要注意:递归构造器调用. 普通函数的调用是:this.run(); 而构造函数调用是this();这样来调用.

类必须要定义构造函数

3.其实每一个类中至少都有一个构造函数的,如果定义类时,没有显示的声明任何的构造函数.系统会自动的为这个类创建了一个不带任何参数的构造函数.
如果你在一个类中创建了一个显式的构造函数.那么,虚拟机就不会自动的为你创建

构造函数的访问权限

4.一般在定义构造函数的时,如果没有特殊的需求(就好单例)应该使用public关键字来修饰构造函数
在一些特殊的情况使用private关键字

new Person()虚拟机做了什么事?

1.首先把类加载进来
2.为这个类创建对象.并且为成员变量初始化
3.自动的调用构造函数里面的内容


三:this关键字

this的引用

1.this关键字一般用于方法内
2.this代表是一个对象的引用
具体引用那个对象,就看这个调用方法的对象

this的应用场景

1.当在一个类中要明确指出使用对象自己的的变量或函数时就应该加上this引用 ,此时this是指当前对象自己。

2.当你要把自己作为参数传递给别的对象时,也可以用this关键字,此时this被作为参数传递。

在内部类中也会经常使用this关键字,此时this代表内部类对象,如想引用外部类对象,this前面还需要加上外部类的类名。
在构造函数中,可以使用this(实参)来调用该类的其他构造函数,此时,应注意,调用代码只能在第一行,在别的方法中不能这样调构造函数,在一个构造函数中只能调一个构造函数(因为都必须放在前面啦.所以只能调用一个)


四.函数的参数传递

1.基本数据类型在参数传递过程中值是不会改变的
(int ,byte,char,long,short,double,float,boolean )

2.引用数据类型在参数传递的过程中,其值是会被改变的.

五:static关键字之静态变量

static关键字:在程序中使用static关键字来修饰一个成员

类什么时候加载?
类只会加载一次,又因为static修饰的变量是随着类的加载而加载的. 所以其值是被任何的对象所共享.

1.静态变量修饰的属性是被所有类的实例所共享

2.静态变量可以通过类名.属性名直接访问.(因为它是随着类的加载而加载.只能加载一次)

3.静态变量在类的加载时就完成了初始化.


第六:Static关键字之静态方法

1.用static修饰的方法是静态方法

2.在类加载后,就可以直接通过类名来调用静态方法

3.可以使用类名.方法名来直接访问

4.静态方法的内部是不能直接的访问非静态的成员
原因:
因为静态访问在类加载后就可以直接调用了,而非静态的成员则需要创建对象才可以调用.所以是不能直接的来访问非静态的成员

5.静态方法内部,只能通过创建该类的对象才可以访问非static的方法.静态方法中是不能使用this关键字,因为静态方法没有别的引用. 静态方法中也没有所谓的对象。

6.静态的方法的应用:

1. 一般在工具类上面.因为工具类是可以直接调用调用就可以使用了嘛.
2.生产对象中也可以使用。

posted @ 2012-08-07 00:54 、小细 阅读(62) | 评论 (0)编辑 收藏

面向对象:一种编程思想,使用对象来描述生活中的事物:
面向对象的四大特征: 1.封装 2.继承 3.多态 4.抽象
1.类和对象:
类是对象的抽象,对象是类的实例

2.this关键字是一个对象的引用,thiis在方法内,谁调用我.我就为谁服务

3.创建对象:

Person p ;
p = new Person();
1.在栈内存中定义一个变量p ,类型是:person
2.在堆内存中,首先加载一个Person.class字节码
3.在堆内存中创建一个对象 new Person ()的一个实例
4.自动初始化堆内存里面的数据
5.把所创建的首地址变量赋值给p引用

4.对象的生命周期:
当对象被创建到失去所有的引用(没有任何一个变量记住它的首地址,)这期间我们称之为对象的生命
周期,当对象的生命周期结束后!就会变成垃圾对象,等待java的虚拟机回收!

5.匿名对象
1.匿名对象只使用一次就会被java的垃圾回收机制自动回收,用途:如果对一个对象只进行一次的调用,那么就可以使用匿名对象

2.咱们一般是在匿名对象作为实参传送给一个函数。


2.类的封装:

概念:将一系列特征相似的对象共同的属性和行为抽象出来用一个类来描述.

类的成员变量描述的是属性,类的成员方法描述的是对象的行为
为了实现良好的封装性,需要将类的成员变量私有化(private),对外提供了set 与get方法
但是boolean 的最好使用 is

属性私有化:
1.更加符合现实的逻辑
2.更加正确地控制别人的属性访问权限
3.防止一些错误的操作!
方法有时候也需要封装.

3.构造函数:

1.函数的名称一定要和类名相同
2.没有返回值声明
3.不能在语句中使用return 语句返回一个值!
构造函数的作用:
当我们使用new关键字来创建第一个对象的时,java的虚拟机就会自动的会调用构造函数.
我们可以为构造函数中做一些初始化的信息!
但要注意的问题:这个初始化的name 与age 并不是代表了:this的


构造方法的具体应用;

1.构造方法是可以被重载的(参数类型不一致就可以)
2.构造函数也可以添加访问权限!不过一般建议使用public关键字来修饰.

个人心得总结:
      今天的学习算是比较满意吧!但是有一点注意的: 还是有一点点分心!
      第二:认真听课。
      要多听课!个人在感觉这块了解不够深入.

posted @ 2012-08-07 00:52 、小细 阅读(52) | 评论 (0)编辑 收藏



一、判断题
1、Java语言是不区分大小写的。 错,Java语言是严格区分大小写的
2、Java程序源文件的扩展名为“.jar”。 错,Java程序源文件的扩展名为”.java” 
3、Java程序一般应含有main方法,因为它是所有java程序的入口。正确
4、声明main方法时,其声明可以写成:
Public static void main(String args[])
也可以写成:
Public static void main(String s[])   
 不正确,P不应该大写,应该小写,其他地方是正确的
6、假设有一个名为Hello的java源程序,那么编译这个文件的命令为javac Hello.java。
  正确
7、当运行java程序时,类加载器将字节码加载到内存中,字节码检验器确认所有的字节码是合法的并且不会破坏java的安全限制,然后解释器读取这些字节码并将它们翻译成计算机能够执行的语言。
正确
8、在java语言中,每个ASCII码英文字符占用8个二进制位,而每个中文汉字字符占用16个二进制位。FALSE
正确 英文字符占1个字节8位,中文字符占2个字节16位
9、short s = 64000语句是否正确。
不正确,超出short的取值范围和应该在64000后面加上分号“;”

二、填空题    
1、Sun公司提供了三种java开发工具:其用于工作站和个人计算机的标准开发工具为_
java se _____,用于企业级开发的工具为_java ee______,用于智能移动产品的工具为__ java me______。

2、Java程序中的数据类型分为哪两种_基本数据类型和引用数据类型__________________________。
8种基本数据类型 数值型(byte short int long float double)字符型 char  
布尔型 (Boolean) true 和false
引用数据类型 类,接口,数组
3、配置java开发和运行环境,通常需要配置哪两个环境变量___path_______和________classpath____。

4、在java源文件中,可以有哪几种类型的注释_____单行注释 多行注释和文档注释___________________________。

5、查看当前java虚似机版本的java命令为___java -version________。

6、设一个java源文件的名字为Test.java,则编译该文件的命令为_javac Test.java_____,运行的命令为___java Test___。

7、Java虚似机运行java程序过程为:首先从后缀为_.class____的文件加载代码到内存中,然后在内存中__字节码检验器检查______代码的合法性和安全性,然后___解释器____执行合法和安全的代码。

8、Java语言在____1995______年由____SUN______公司第一次正式发布的,__
詹姆斯•戈斯林(James Gosling)________被誉为java之父。

9、设Hello.java文件的内容如下:
class Hello
{
    static void main(String args[])
    {
        System.out.println(“Hello World!”);
    }
}
下面说法正确的是:D
A、    无法通过编译,因为main方法声明不对。
B、    可以编译,但不可以运行。
C、    可以编译,并可以输出正常结果。
D、    可以编译,但不可以运行,因为文件中没有public类。
  
10、请写出下面程序的运行结果____12_______:
public class Test
{
    public static void main(String args[])
    {
        int i = 0;
        while(true)
        {
            if(i++>10)
            {
                break;
            }
        }
        System.out.printnln(i);
    }
}
X++和++X的区别: X++是X先参与运算再自增,++X是先自增再参与运算
11、请写出下面程序的运行结果____11_______:
public class Test
{
    public static void main(String args[])
    {
        int i = 0;
        while(true)
        {
            if(++i>10)
            {
                break;
            }
        }
        System.out.printnln(i);
    }
}
12、请写出下面程序的运行结果________4________
class Test
{
    public static void main(String args[])
    {
        int a=1,b=2;
        if((a==0)&(++b==6))
            a = 100;
        System.out.println(a+b);
    }
}
(a==0)这个条件为false  (++b==6)这个条件首先b自增1后再参与比较,b变成了3,但这个条件也不成立,所以”a=100;”这个语句没有执行,最后(a+b)的值为(1+3)=4
13、请写出下面程序的运行结果_____4______________。
class Test
{
    public static int method(int x)
    {
        int j = 1;
        switch(x)
        {
            case 1:
                j++;
            case 2:
                j++;
            case 3:
                j++;
            case 4:
                j++;
            case 5:
                j++;
            default:
                j++;
        }
        return j;
    }
    public static void main(String args[])
    {
        System.out.println(method(4));
    }
}

14、请写出下面程序的运行结果_______7____________。
class Test
{
    public static void main(String args[])
    {
        int a = 2;
        switch(a)
        {
            case 1:
                a +=1;
                break;
            case 2:
                a +=2;
            case 3:
                a +=3;
                break;
            case 4:
                a +=4;
                break;
            default:
                a = 0;
        }
        System.out.println(a);
        
    }
}

三、简答题:
1、请判断下面的程序是否能正常编译并运行,如能编译请写出运行结果,如不能请改正。
    int i = 0;
    do
        System.out.println(i++);
    while(i<5);

  正确 :结果为 0
                1
                2
3
4
2、请指出下面程序可能出现的问题。
    class Test
    {
        public static void main(String args[])
        {
            int i = 0;
            do
{
    System.out.println(i++);
}
        }
    }
没有while 语句,do语句没有中止,不是正确的写法
3、请总结break、continue和return的具体用法,并写出相应的示例程序。
break于中止当前循环中的子语句
continue 语句只能出现在循环语句中,用于跳出循环的剩余语句块,接着执行下一次循环
for(int i=0;i<10;i++)
 {
          if(i%2==0)
        {
               continue; 
        }
      System.out.println(i);
 }
return 用于结束当前执行的语句,并返回一个值
static int getMax(int num1,int num2,int num3)
    {      
         
        int max=num1>num2?num1:num2;
            max=max>num3?max:num3;
        return max ;
    }

四、程序题:
1、    请编写程序,计算1+3+5+……………………+1999的结果。
源程序://FindSum.java
    public class FindSum
{
    public static void main(String args[])
    {
        int n = 1999 ;
        int sum = findSum(n);
        System.out.println("从0到"+n+"之间的奇数和为:");
        System.out.println("sum="+sum);
    }
    
    static int findSum(int n)
    {
        int sum=0;
        for(int i=0; i<=n; i++)
        {
            if(i%2==1)
                sum+=i;    
        }
        return sum;
    }
}
运行结果:
 
2、    请定义一个整数数组,用一种排序算法对这个数组进行排序。
 源代码://Demo42.java
public class Demo42
{
    public static void main(String args[])
    {
        int [] num = {12,45,10,23,5,123,89,411,9,78};
        
        System.out.println("排序前:");
        arrList(num);
        
        selectSort(num);
        System.out.println("排序后:");        
        arrList(num);
        
    }
    static void selectSort(int [] arr)
    {
        for(int i=0; i<arr.length-1; i++)
        {
            int pos = i;
            int max = arr[i];
            for(int j=i+1; j<arr.length;j++)
            {
                if(arr[j]>max)
                {
                    max = arr[j];
                    pos = j;
                }
            }
            exchange(arr,i,pos);
        }
            
    }
    static void exchange(int [] arr,int pos1,int pos2)
    {
        int temp;
        temp = arr[pos1];
        arr[pos1] = arr[pos2];
        arr[pos2] = temp;
    }
    static void arrList(int [] arr)
    {
        StringBuffer sb = new StringBuffer();
        for(int i=0; i<arr.length; i++)
            sb.append(arr[i] + ",");
        sb.delete(sb.length()-1,sb.length());
        System.out.println(sb);
            
    }
}
运行结果:
 


3、    请用System.arraycopy实现数组的拷贝。
源代码://Demo43.java
public class Demo43
{
    public static void main(String args[])
    {
        int [] num1 = {15,89,16,56,10,2,5,123,84,99,753,612};
        int [] num2 = {789,145,100,20,36,95,88,71,40,126,91,65};
        System.out.println("数组拷贝前:");
        arrList(num1);
        arrList(num2);
        
        System.arraycopy(num1,3,num2,3,6);
        System.out.println("数组拷贝后:");
        arrList(num1);
        arrList(num2);        
    }
    
    static void arrList(int [] num)
    {
        StringBuffer sb = new StringBuffer();
        for(int i=0; i<num.length; i++)
        {
            sb.append(num[i]+",");
        }
        sb.delete(sb.length()-1,sb.length());
        System.out.println(sb);
    }
}
运行结果:
 

4、    编写一个程序,程序里定义三个数,并输出这三个数的最大数。
源代码://Demo44.java
class Demo
{
    public static void main(String args [])
    {
        int num1 = Integer.parseInt(args[0]);
        int num2 = Integer.parseInt(args[1]);
        int num3 = Integer.parseInt(args[2]);
        System.out.println("这三个数的最大值是:");
        System.out.println(getMax(num1,num2,num3));
    }
    static int getMax(int num1,int num2,int num3)
    {      
         
        int max=num1>num2?num1:num2;
            max=max>num3?max:num3;
        return max ;
    }
}

运行结果:
 
5、    编写一个程序,这个程序把一个整数数组中的每个元素用逗号连接成一个字符串,例如,根据内容为[1][2][3]的数组形成内容为“1,2,3”的字符串。 
源代码://Demo45.java
  class arrDemo
{
    public static void main(String args [] )
    {
        int [] arr = {12,89,45,61,568,945,102,302,44,777,945,689};
        System.out.println("依次输出数组中的元素:");
        arrList(arr);
    }
    static void arrList(int [] arr)
    {
        StringBuffer sb = new StringBuffer();
        for(int i=0; i<arr.length; i++)
            sb.append(arr[i]+",");
        sb.delete(sb.length()-1,sb.length());
        System.out.println(sb);
    }
    
}
运行结果:
 
6、    编写一个程序,从键盘上接受用户输入的需要转的数,得到的一定是字符串,将此字符串转换成十进制整数,然后打印出这个十进制整数对应的二进制形式。
源代码://Demo46.java
class appDemo
{
    public static void main (String args [])
    {
        int num = Integer.parseInt(args[0]);
        System.out.println("输入的整数为:"+num);
        System.out.println("这个十进制的整数对应的二进制形式为:");
        ten2Binary(num);
    }
    static void ten2Binary(int num)
    {
        StringBuffer sb = new StringBuffer();
        while(num>0)
        {
            int temp = num%2;
            num=num/2;
            sb.append(temp);            
        }
        sb.reverse();
        System.out.println(sb);            
    }
}
运行结果:
 

7、     请用移位的方式打印出一个十进制整数的十六进制形式。提示:按每4个二进制位对整数进行移位和去高位处理,得到的结果就是十六进制数的一位,然后按下面三种方式之一(作为作业,要求每种方式都用到)计算出一个十六进制数值对应的十六进制形式: 
1)0-9之间的数值直接加上字符'0',9以上的数值减去10以后再加上字符'A' 
2)定义一个数组,其中包含0-F这些字符,然后用要计算的数值作为数组的索引号,即可获得其对应的十六进制数据。 
3)Character.forDigit静态方法可以将一个十六进制的数字转变成其对应的字符表示形式,例如,根据数值15返回字符'F'。 
源代码://Demo47.java
class hDemo
{
    public static void main(String args[])
    {
        int num = Integer.parseInt(args[0]);
        System.out.println("输入的整数为:"+num);
        System.out.println("这个十进制整数对应的十六进制形式是:");
        ten2Hex(num);
    }
    static void ten2Hex(int num)
    {
        StringBuffer sb = new StringBuffer();
        char[] buf = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
        for(int i=0; i<8; i++)
        {
            int temp = num&0x000000000f;
            sb.append(buf[temp]);
            num=num>>4;
        }
        sb.reverse();
        System.out.println(sb);        
        
    }
}
运行结果:
 
posted @ 2012-08-07 00:50 、小细 阅读(79) | 评论 (0)编辑 收藏

一:java的基本语法

       1.代码都是存放在class里面的

       2.严格区分大小写(num NUM)是两个不同的变量

       3.格式自由.

       4.单行注释与多行注释的和文档注释

       5.标识符:

       全部使用英文字母,骆驼式命名:从第二个单词开始,每个单词的首字母都要大写,其它的小写

(标识符不能为关键字,不能以数字开头)

 

二:java中的变量

    1.有八个原声数据类型和引用数据类型.

    2.类型转换:

      byte、short、char类型在运行过程中都会提升为int 类型(这样的方式叫自动类型)我们可以将一个int类型强制转换成byte、short、char类型 (需要强制类型转换!显示类型转换丢失精度.

      System.out.println('a'+1); 因为 1是int类型的,所以会升级为int 类型.

      System.out.println(""+'a'+1);(任何数字和字符串相并且都自动转换成字符串).

    3.变量的生命周期:

      在方法内定义的变量,当方法被调用的时候,变量被定义,当方法接收的时候。变量也会随着方法释放掉变量的作用域内是不可以重复定义,超出变量的作用域,变量将不能访问.

 

三:java中的函数

    1.定义:函数,又称为方法,能够完成某特定代码的代码块,其个名字,方便于方法的调用函数的作用: 就是可以重复的去利用某一段代码

    2.函数必须有的: 函数名 返回值  返回值类型  (形式参数看需求而定)

    3.形参:方法定义的形参相当于在方法中定义了一个局部变量,当这个方法被调用的时候,也就是对其方法里面的参数初始化啦!初始值为传递进来的参数

    4.返回值类型:可以为任意一个类型,有一种特殊:当方法没有返回值的时候,我们要把返回值类型定义为(void)

    5.return :在方法中可以使用return 返回一个值,(返回的值必须是与返回值类型一致)

    6.方法的重载:

              多个函数具有相同的名字,参数的个数或者类型不同都可以.  返回值类型不能做衡量方法的重载

 

四:java中的运算符

 

1.算术运算符   % 取模,也叫做取余

  ++自增1,--自减1

  ++x 与x++的区别: 本质上是没有区别的,x++是先参与运算再自加  ,而++x先自加一次才参与运算

  在取模运算中,模数的符号会被忽略,被模数符号不能被忽略

2.赋值运算符 = 是赋值的意思

  += ,-=,*=,\=,%=

3.比较运算符号: == 是相互比较的意思

    instanceof:判断该对象是否是属于指定的类型

4.逻辑运算符

    &和&&的区别:

      1. &&如果左边为假,结果注定为假,右边不参与运算

                 2.&如果左边为假,结构注定为假,但是右边会参与运算

    |和||的区别:

      1.如果左边为真,结果注定为真,右边不参与运算

                 2.如果左边为真,结果注定为真,右边参与运算

 

5.位运算符

    &(与):真真得真,真假得假,假假得假

    |(或):真假为真,真真为真,假假为假

    ^(异或):任何一个数与一个指定的数异或两次,其结果等于本身,(第一个数异或第二个数 其结果再异或第二个.其结果等于它本身)(不同为1,相同为0)

    移位运算符:

      <<左移,砍掉高位,低位补0 一定要把它更改成32位。(左移N位相当于乘以2的N次方)

                >>右移,砍掉低位,高位要看最高位的符号。符号位为1,就补1,符号位为0就补0(右移N位,相当于除以2的N次方)

6.switch

switch中的参数是必须是int类型的,但是byte,short,char都是隐式的自动类型提升啦~

break :结束循环

continue:提前结束本次循环,进入到下一次循环

 

 

总结:后期学习不认真!估计时间不安排好!!。。注意。

 

 

  1 小算法复习:
  2 /*
  3     不用第三方变量交换两个数的值
  4 
  5     异或:第一个数异或第二个数,之后再把结果异或第二个数。其结果等于它本身!
  6 
  7     1.<<最高位砍掉,最低位补零
  8     (左移多少位,其实就是*2的N次方)
  9     2.>>最低位砍掉.如果最高位是1,前面就是补1,否则补0
 10     //(又移多少位,就是/2的N次方)
 11 */
 12 
 13 class Demo 
 14 {
 15     public static void main(String[] args) 
 16     {
 17         int a = 3;
 18         int b = 5;
 19 
 20         a = a ^ b;
 21         b = a ^ b;
 22         a = a ^ b ;
 23         System.out.println("a == "+a);
 24         System.out.println("b =="+b);
 25 
 26     }
 27 }
 28 /*某个培训中心要为新到的学员安排房间,假设共有x个学员,
 29 每个房间可以住6人,让你用一个公式来计算他们要住的房间数
 30 */
 31 
 32 
 33 class  Demo
 34 {
 35     public static void main(String[] args) 
 36     {
 37         int num = 48;
 38         int homeNuber = getHomeNumber(num);
 39         System.out.println("学生的个数为:"+homeNuber);
 40     }
 41     static int getHomeNumber(int num)  //形式参数的初始化其实就是传递进来的参数帮他初始化啦~
 42     {
 43         return (num+5)/6;  //给一个最大的限度!
 44     }
 45 }
 46 
 47 /*
 48     利用无限循环实现0 - 9 之间的数之间的重复循环
 49 */
 50 
 51 class Demo 
 52 {
 53     public static void main(String[] args) 
 54     {
 55         int x = 0;
 56         while(true)
 57         {
 58 
 59             x = (x+1)%10;
 60             System.out.println(x);
 61         }
 62     }
 63 }
 64 
 65 /*
 66     利用小技巧把10进制转换成2进制代码!
 67 */
 68 import java.io.*;
 69 class Demo 
 70 {
 71     public static void main(String[] args) throws Exception
 72     {
 73         //读取键盘
 74         BufferedReader br = 
 75                 new BufferedReader(new InputStreamReader(System.in));
 76         System.out.println("本程序可以帮助您把十进制代码转换成二进制代码:");
 77         String line = br.readLine();
 78         int num = Integer.parseInt(line);
 79         StringBuffer sb = new StringBuffer();
 80         while(num>0)
 81         {
 82             int temp = num % 2; //获取到除以2的余数!
 83             sb.append(temp);
 84             num = num / 2; 
 85         }
 86             sb.reverse();
 87             System.out.println(sb);
 88     }
 89 }
 90 
 91 
 92 /*
 93     十进制转换成十六进制之方法一。
 94 */
 95 import java.io.*;
 96 class  Demo5
 97 {
 98     public static void main(String[] args) throws Exception
 99     {
100         BufferedReader br = 
101                             new BufferedReader(new InputStreamReader(System.in));
102 
103         System.out.println("本程序可以通过十进制转换成十六进制:");
104         
105         String line = br.readLine();
106         int num = Integer.parseInt(line);
107 
108         StringBuffer sb = new StringBuffer();
109         while(num>0)
110         {
111             int temp = num % 16;
112             if(temp>9)
113             {
114                 sb.append((char)(temp-10+'A'));
115             }else
116             {
117                 sb.append(temp);
118             }
119             num = num / 16;
120         }
121         sb.reverse();
122         System.out.println(sb);
123     }
124 }
125 
126 
127 /*
128 用移位的方法来求一个数
129 
130 十进制转换成十六进制
131 */
132 import java.io.*;
133 class Demo 
134 {
135     public static void main(String[] args) throws Exception
136     {
137         BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
138         System.out.println("本程序可以帮助您从十进制转换到十六进制:");
139         String line = br.readLine();
140         int num = Integer.parseInt(line);
141         Ten2Hex(num);
142     }
143 
144     static void Ten2Hex(int num)
145     {
146         StringBuffer sb = new StringBuffer();
147         int count = 0x00000000f;
148         for(int i = 0;i<8;i++)
149         {
150             int temp = num & count;  
151             if(temp>9)
152             {
153                 sb.append((char)((temp-10)+'A'));  //类型要注意
154             }
155             else
156             {
157                 sb.append(temp);
158             }
159             num = num >>4;
160             
161         }
162         sb.reverse();
163         System.out.println("结果为:"+sb);
164     }
165 }
166 
167 /*
168     打印金字塔程序!
169     求算法的时候要注意:
170     找到求第一个的规律.
171     然后循环就可以。
172 */
173 
174 
175 class Demo 
176 {
177     public static void main(String[] args) 
178     {
179         int n = 4;
180         for(int i = 0;i<n;i++)
181         {
182             for(int j = 0;j<n-i;j++)
183             {
184                     System.out.print(" ");
185             }
186             for(int k =0;k<i*2-1;k++)
187             {
188                     System.out.print("*");
189             }
190             System.out.println();
191         }
192     }
193 }
194 
195 
196 总结:
197     其实switch的参数必须是int类型的,为什么byte char short参数可以传递进来呢?
198 因为它的类型自动提升为int类型啦。也就是隐式的进行了强制转换/所以是可以的.
posted @ 2012-08-07 00:40 、小细 阅读(50) | 评论 (0)编辑 收藏

一.java是一门高级的语言,具有跨平台(一处编译,到处运行)

1.javac 编译源文件.java

2.运行源文件 java 启动虚拟机

3.cls 清空dos界面文字!

4.java源文件 -->java.class(字节码) -->windows(jvm)  -->linux(jvm)

二:path环境变量

1.什么是path环境变量 ?path环境变量的作用?

解答:当我们运行一个exe可执行的文件的时候,系统会首先在当前的目录下去寻找,寻找不到的时候就会在注册表中寻找.如果没有了最后才到path环境变量中寻找.

所以当我们想成功的在任何的目录下运行javac 与java命令的时候,我们一定要把环境变量设置在path中.

2.查看path环境变量的两种方式

解答:

第一种:我们可以通过在dos窗口里面输入 set path命令查看path环境变量.

第二种:我们可以系统中查看到path环境变量的设置(图形窗口里面)。

3.如何设置path环境变量

解答:

新建: JAVA_HOME: D:\java\jdk\(这部分内容是经常要修改的)

在path环境下面:%JAVA_HOME%bin;

4.%path% 的意义?

解答: 表示对path里面的做引用

java -version 表示查看当前的java版本好

class Path的作用:

类加载时,java虚拟机会在classpath指定的目录下找相对应的class文件

在编译时可以使用绝对路径名,运行时则不能.

三.进制的转换

1b = 8bit

1kb = 2^10b  = 1024b

1mb = 102kb

1g = 1024mb

1t = 1024g

十进制转换成二进制:

八进制转换成二进制:

十六进制转换成二进制:

将需要转换的数字除以2,获取到商和余数.将商继续除以2,取到商为零.最后将所有的余数倒序排列.得到的就是该转换出来的结果!

八进制转换成二进制:

十进制转换成二进制:除以2,直到商为零。将余数反转

小数除以大数,则商为零。余数是小数本身

二进制转换成十进制呢?

101 

解题:

1*2^0 + 0*2^1+1*2^2 = 6;

2^0(相当于)没有!

二进制转换成八进制:每三个为一个整体  二进制转换成十六进制的每4个位一个整体/

八进制转换成十进制:

24

解题:

4*8^0+2*8^1 = 4+16 = 20 

计算机的运行原理:  都是累加器的

5 - 5 其实在计算机中运行效果是: 5+(-5)

负数是如何表示的? 

原码 取反 反码 加1  补码

总结:

如何将二进制,八进制  ,十六进制转换成十进制呢?

12F 转换成十进制:

15*16^0+2*16^1+1*16^2 = 15+ 32 + 256 = 303 其实就是12f

都是采用乘法。

如果将十进制转换成二进制,十六进制  八进制呢?

都是采用除法,取余.

关于原码,反码与补码:

-5 原码: 101

反码: 010

补码: 011

因为是32位所以: 1111 1111 1111 1111 1111 1111 1111 1011

 

 1 class Test2
 2 {
 3     public static void main(String[]args)
 4     {
 5         StringBuffer sb = new StringBuffer();
 6         int num = 1234;
 7         while(num>0)
 8         {
 9             int temp = num % 16;
10             if(temp>9)
11             {
12                 sb.append((char)temp-10+'A');
13             }
14             else
15             {
16                 sb.append(temp);
17             }
18             num = num / 16;
19         }
20         System.out.println(sb);
21 
22     }
23 }

个人总结:
  总体来说今天的学习认真度还是很不够的!咱们要注意的地方就是:学习的时候不能分心.小细.一定不要输给别人看.

posted @ 2012-08-06 18:26 、小细 阅读(64) | 评论 (0)编辑 收藏