java基础的知识

1. java的基础知识~！！

哎呀，问的好。
对此，本人以一个高深的Java专家给你作答（装的）：
区别如下：
1、方法有返回类型，方法名小写，不能和类名相同；构造方法没有返回类型，void也不行，名与类名相同。
2、构造方法是初始化对象的重要途径，所以就算你给一个类没有定义构造方法，方法在这个类的加载得时候，会自动提供一个没有参数的构造方法。所以，常见得 Student s=new Student();那么，s这个实例，是通过构造方法初始化的；而普通方法不行
3、他们运行顺序不同。一个类在初始化的时候，例如People是Student的父类，有构造方法 public PeoPle(){}那么，当实例化Student p=new Student()得时候，父类的构造方法会隐式执行（你可自己敲代码尝试，父类构造方法中写个输出语句：例如System.out.println("父类构造方法")）。你会发现，没有调用任何父类，也没有实例化父类，但是构造方法却执行了。
4、方法仅仅是类成员，构造方法也是类成员，但是，构造方法有对类属性得初始化的功能。所以，常见到 public PeoPle(String name){this.name=name}或者 public PeoPle(){name="wangsan",age=14},完成了对People类属性name或者age的初始化
…………
难以言尽
但是，只是作为理解，会用就可以了。

2. java基础知识——<>的意义

首先你要理解面向对象编程。

“Everything is Object”——“万物皆对象”。语出Java之父，那个急死你·搞死你说的。

意思就是其实啥玩意你都可以看成一个对象，或者一个类。

类是对一类事物的抽象定义，对象是这个类具体的实现实例。

“人”是一种类，而“刘德华”就是人这个类的具体对象。

从这个理念出发，扩展出反射的概念。那么，其实，我们能将“人”这个类本身，也视为一个对象。

Class c2 = boolean.class，实际上定义了一个“类对象”，这个对象中有这个类的相关属性方法（这里有点绕）。
具体来说就是“boolean”这个类的一些性质。从底层上来说，boolean.class是boolean这种数据结构的字形码。

用我的例子来说， Class c = 人.class,我们得到的就是“人”这个类的类对象，也就是他的字节码。我们可以通过这个字节码，去构造一个新的人。这就是Java的反射机制了。

考虑如下情形：你是一个架构层的开发员（你的客户就是Java程序员），你在指定任何一套供人扩展的框架时，肯定会定义很多底层操作。比如 新建一个类。但是你不知道这个类的类名，方法名什么的（你不知道你的客户会写出什么类名）。
那么如何能实现这个需求呢。这时候只能使用反射，拿到这个类的字节码（类对象），通过反射机制，去得到这个类的实例。

任何类名都可以通过 类名.class 点出它的类对象（字形码），也可以通过该类的某个实力 o.getClass()方法得到这个字形码。就是你写的这两个例子所代表的含义。

3. Java开发的基础知识有哪些

1、Java语言的优点：
1)Java是纯面向对象语言
2)与平台无关性，一次编译到处运行
3)Java提供了狠多内置类库
4)提供了对web应用的支持
5)具有较好的安全性（数组边界检测、Bytecode检测）和健壮性（强制型机制、垃圾回收器、异常处理）
6)去除c++难以理解的一些特性（头文件 指针 运算符重载 多重继承）
2、java与c++的异同：
1)Java为解释型语言，c++为编译型语言，java会慢但是跨平台
2)Jave为纯面向对象，c++既面向对象又能面向过程。Jave无全局变量和全局函数
3)Java没有指针，更安全
4)Java不支持多继承但是有接口概念
5)Java不需人工分配管理内存（申请 释放），提供垃圾回收器自动回收。当堆栈或静态存储区没有对这个对象的引用时，就会被回收。没有析构函数，但是有finalize()方法。
6)Java没有运算符重载，没有预处理功能。
3、public static void main(String [] args)是程序的入口。
4、java可有多个main()文件，但只有与文件名相同的用public修饰的类的main()才能作为程序的入口。注：有且仅有一个类被public修饰并与文件同名。
5、静态快在main函数之前执行。初始化执行顺序：父静态变量 父静态代码块 子静态代码变量 子静态代码块 父非静态变量 父非静态代码块 父类构造函数 子非静态变量 子非静态代码块 子类构造函数
6、构造函数：
1)与类同名，无返回值
2)可以有多个，根据参数不同
3)总是伴随new操作一起调用
4)主要用来初始化对象
5)不能被继承
6)可用super来显示调用父类构造函数
7、浅复制仅仅复制考虑的对象，不复制它引用的对象。深复制两者都复制
8、面向对象和面向过程有什么不同：
1)面向对象是用符合常规思维的方式去处理客观世界的问题，面向过程是则重以事件为中心，模块化。
2)面向对象是使计算机世界向客观世界靠拢，使问题的处理更清晰。面向过程是清晰准确表达过程的模块，把客观世界的问题抽象成计算机可以处理的过程。
9、面向对象的特征和优点：抽象 继承 封装 多态有较高的开发效率，代码可重用。较高的可维护性，代码更清晰明了。
10、java只支持单根继承，extends继承是 is a 关系，组合是 has a关系。
在java语言中能用到组合的尽量不要用继承。
11、多态：
重载（同个类中有多个同名方法） 水平关系
重写（子类重写父类，方法名和参数列表相同） 垂直关系
12、抽象类和接口的异同：
1)只要包含一个抽象方法都是抽象类，接口的方法全部是抽象方法，称为纯抽象类。
2)抽象类的子类需实现父类的抽象方法。
3)接口中的变量都默认为：static final 必须赋初值。
4)接口实现用implements。一个类可以实现多个接口实现类似多继承的关系。
5)接口被运用于常用的功能，如：添加删除。抽象类用于生活公共类的角色，不适用经常对代码修改的情况
13、this和super的区别：
This用来指向当前实例对象
Super用来访问父类的方法和成员变量
子类继承父类时，子类构造函数中super（）必须放第一句。
14、break continue return 的区别：
Break 用于直接强行跳出当前循环，不执行剩余代码
Continue 用于停止当次循环，回到起始处进行下次循环。
Return 跳转 用来表示从一个方法中返回。
Break out跳出多重循环
15、static的作用：
a 为对象分配单一的存储空间，与创建对象个数无关
b 实现某个方法或属性和类而不是与对象关联在一起
C 变量可达到全局的效果，在内存中只有一个复制
16、不可变类的实现：
类中的所有成员变量被private修饰
没有写set方法
类定义final
17、值传递和引用传递的区别:
值传递：实参会把它的值传递给形参
引用传递：传递的是对象，形参和实参指向同个存储单元。
18、有八种基本数据类型，类型转换的优先级：byte不能与booleam互换。
19、round 表示四舍五入 ceil表示向上取整 floor表示向下取整，i++表示先执行后加
一，++i表示先加一后执行。
20、String s1=”abc”是存放在常量区
String s2=”abc”s2应用常量区的对象，不会创建新的对象。
String s3=new String（“abc”）是在堆中创建对象，
String s4=new String（“abc”）又必须在堆中创建新对象。
21、“==”与“equals”
“==”用来比较两个变量的值是否相等，如果一个变量指向饿数据是对象（引用类型），就有两块内存。对象本身占用一块内存（堆内存），变量也占用一块内存。String s4 = new String（“abc”）。变量s所对应的内存中存储的数值就是对象占用那块内存的首地址。如果想看两个变量是否指向同一个对象，即要看他们对应内存中的数值（首地址）是否相同。
equals比较的不是引用，而是数值内容，即比较的是abc。
22、数组也是对象。数组提供length属性来获取数组的长度，而String是通过length()计算。
23、异常处理
1）try catch finally模式
2）Finally块中的代码一定会被执行，除非这两种情况：当程序在try之前就遇到异常或者在try中通过exit（）强制退出。
3）jvm将错误表示为一个异常并抛出，通过catch来捕获，然后进行处理。安全性和鲁棒性。
4）异常分为两大类：错误（error）和异常（Excetion）
异常分为：检查异常和运行异常。
检查异常又称为编译异常。
比如：IO异常、SQL异常
运行异常为：空指针异常、类型转换异常、算术异常、数组越界异常、数组存储异常、缓存区溢出异常。
先捕获子类后捕获父类，尽早抛出异常，能处理就处理，不处理就抛出，运行时异常实际不必处理，直接抛出。
24、Java IO：字节流（8位）不会用到缓存 字符流（16位）用到缓存
25、Socket称为套接字。用来实现不同虚拟机或不同计算机之间的通信。
分为两种类型：面向连接的TCP,可靠。无面向连接的UDP，不可靠。
任何一个Socket都是由一个IP地址和端口号唯一确定。
26、java平台独立性是指一个平台上编写和编译程序，而在其他平台上运行。有JVM和java API。
Java语言是一种动态解释型语言，类class只有被加载到JVM上才能运行。不会一次加载全部类后执行，而是先加载基类，其他类是需要时再加载。
27、垃圾回收GC：回收不会再使用的内存。三个任务：分配内存；确保被引用的内存不被错误地回收；回收不再被引用的对象的内存。
28、java中内存泄露问题：
两种情况：
1）在堆中申请的空间没有得到释放
2）对象不再被使用，但是仍在内存中保留着
原因：静态集合类、各种连接、监听器、变量不合理的作用域
29、java中堆和栈的区别：
分配在栈：基本数据类型的变量、对象的引用变量
变量出了作用域就会被自动释放
分配在堆：引用类型变量、需要通过new创建的变量。主要为运行时创建的对象
JVM是基于堆栈的虚拟机，每个java程序都运行在一个单独的JVM实例上，所以一个java程序中的对个线程运行在，每个实例又唯一对应一个堆，所以这些线程之间会共享堆内存。
只需要申请堆空间，不需要考虑释放问题。
使用栈中的引用变量来访问堆中的数组和对象。
堆只要是用来存放对象的，栈主要是用来放执行程序的。
栈的速度快，但大小和生存期确定，缺乏灵活性。堆是动态分配内存，灵活性强但速度慢。
30、容器：java Collections框架：list 、Queue 、set 、stack 、map
list 、Queue 、set 、stack都继承Collection接口。
1）List是有序的Collection。按对象的进入顺序保存对象，可保存重复对象。
2）Set是集合的概念，集合中不能有重复的元素。
3）map是键映射到值得数据结构。值可以重复，但是键是唯一的，不能重复。
31、迭代器：是一个对象，一种访问一个容器对象的各个元素，而又不必暴露该对象内部的细节方法。
1）使用容器的iterator()方法返回一个Iterator，然后通过Iterator的next（）方法返回一个元素。
2）使用Iterator的hasNext（）方法判断容器中是否还有元素，如果有可以使用next()获取下一个元素。
3）通过remove()来删除迭代器返回的元素。
32、collection和collections的区别：
Collection：是一个集合接口，为各个具体集合提供最大化的统一操作。
Collections：是针对集合类的一个包装类。不能实例化，相当于一个工具类，服务于Collection框架。
33、多线程：
线程：执行代码的一个执行单元。
进程：一个正在执行的程序
各线程共享程序的内存空间（代码段、数据、堆空间）有独立的栈空间。
线程优点：
1）减少程序的响应时间
2）相比进程，创建个切换开销小
3）多CPU和多核本身就具有多线程能力
4）简化程序结构，便于理解和维护。
34、如何实现java多线程：
1）继承Thread类，重写run()方法
2）实现Runnable接口，并实现接口的run（）方法。
3）实现Callable接口，重写call()方法。
35、同步
要想实现同步操作，必须获得每个线程对象的锁，获得它可以保证同一时刻只有一个线程能够进入临界区，并且在这个锁被释放之前，其他线程就能再进入临界区，如果还有其他线程想要获得该对象的锁，只能进入等待队列等待。
36、多进程同步的实现方法：
1）synchronized关键字
2）Wait（）方法与notify（）方法
3）Lock
37、终止线程的方法：stop()方法与suspeng()方法。
Java提供两种线程：守护线程（服务进程）、用户进程。
38、如何通过JDBC来访问数据库：
1）加载JDBC驱动器，将JDBC驱动 jar包复制到lib下
2）加载JDBC驱动
3）创建数据库连接
4）建立Statement对象或是PrepareStatement对象。用于对数据库操作
5）执行SQL语句
6）访问结果集ReaultSet对象
7）依次关闭ReaultSet Statement Connection。
39、Class.forName（）方法的作用是把类加载到JVM中。
在使用JDBC连接数据库之前，一般会调用Class.forName（“com.mysql.jdbc.Driver”）方法来加载驱动。
Statement用于执行不带参数的简单SQL语句，并返回它所生成结果的对象。每次执行SQL，数据库都会编译该SQL语句。
PrepareStatement可执行带参数的。效率更高，可读性，可维护性更高，安全性更好
40、JDBC提供了getString()、getInt()、getIData()等方法从ResultSet中获取数据。
41、在JDBC连接时连接池数目有限，所以一定要保证释放不再使用的连接。
createStatement和prepareStatement最好放在循环外面，而且使用statement后需要及时关闭。最好是执行一次executeQuery后马上关闭statement。
42、Hibernate是JDBC的封装。采用配置文件的形式将数据库的连接参数写到XML中，但
是最后对数据库的访问还是要通过JDBC来完成。
43、Hibernate是个持久层框架，它将表中的信息映射到XML中，再从XML文件映射到相应的持久化类中。
Java Web
1、浏览器的作用：
1)、完成与服务器端的交互。
2)、完成html的解析，实现用户需要看的内容以直观的信息展示出来。
2、HTTP的请求方法有：GET POST HEAD TRACE OPTIONS
GET：是最简单的请求方法，从服务器端获取用户所需的资源，并将其作为响应返回给客户端。获取服务器端的信息（查询）。若需上传数据则添加到URL后面。数据暴露安全不够，并且数量受限制。
POST：除了能够从服务器端获取资源外，同时还可以向服务器上传数据。上传的数据不是在URL中明文显示，可以上传大量数据，用户不可见
3、Servlet:
采用Java语言编写的服务器程序，运行于Web服务器中的Servlet容器中，主要功能是提供请求、响应的服务模式，可以生成动态的Web内容。
Web服务器获取到一个对servlet的请求时，会将其交给Tomcat容器进行处理，容器再通过调用Servlet的方法（doGet（） doPost（））来响应请求。
步骤：
发起servlet请求——>Web服务器交给容器处理——>容器创建两个对象HttpServletResponse HttpServletRequire——>创建单独线程，并将两个对象以参数形式传递进入线程——>线程容器调用Servlet的service（）方法中的doGet()或doPost（）完成响应——>容器将响应消息以HTML形式返回给客户。
4、Servlet的生命周期：
加载——>创建——> 初始化——> 处理客户请求——> 卸载
5、JSP的优点：
JSP:嵌入java代码的html文件。主要解决servlet与HTML的分离。实现业务逻辑与视图进行分离。
6、JSP与servlet的异同：
相同：
本质都是Servlet文件，只要是JSP能完成的工作，使用Servlet都能完成.JSP最终都是会转化为servlet来运行。
不同：
Servlet是处于控制层，主要是做流程控制和业务处理。JSP是处于视图层，主要用于显示。
Servlet没有内置对象，JSP中的内置对象主要是通过HttpServletResponse 对象、HttpServletRequire对象得到。
7、MVC模型：
模型层（M）：实现系统业务逻辑。JavaBean或EJB
视图层（V）：实现用户的交互。JSP
控制层（C）: 实现视图与模型的逻辑控制。servlet
8、控制层：
控制器接收用户的输入并调用模型和视图去完成。
控制器本身不输出任何东西，也不执行任何处理。
只是接收请求并决定使用哪个模型去处理请求，决定使用哪个视图去显示模型处理返回数据
9、MVC的优点：
1）低耦合性，实现视图层与逻辑层分离。
2）高重用性和可适用性
3）部署迅速
4）容易维护
10、Servlet中的forward和redirect有什么区别：
Forward是服务器内部的重定向，服务器直接访问目标地址的url，地址不变。
Redirect:客户端的重定向，完全跳转，地址改变。
11、JSP的内置对象：
1）require（请求对象）
2）Response（响应对象）
3）pageContext（页面上下文对象）
4）Session（会话对象）
5）Application（应用程序对象）
6）Out（输出对象）
7）Config（配置对象）
8）Page（页面对象）
9）Exception（异常对象）
12、request对象的方法：
1）setAttribute（String name ，Object）设置name的属性值
2）getAttribute（String name ）获取name的属性值
3）getParameter（String name ）获取用户提交的数据，name与表单的name对应一致
4）getSession（）用来获取与请求相关的会话
13、JSP中的动作：
1）JSP:include 用来页面请求时引进一个文件
2）Jsp：useBean 用来实例化一个javabean
3）Jsp:setProperty 用来设置已经实例化的bean对象的属性
4）Jsp:getProperty 用来获取已经实例化的bean对象的属性
5）Jsp:foward 用来将请求跳转到另外一个页面
14、JSP中include指令和include动作
指令：<% @include file =”test.jsp “%>
动作：
15、会话跟踪技术：
对同一个用户对服务器的连续请求和接收响应进行监视。
1）page一个页面
2）Request一个请求
3）Session 一个用户体验
4）Application 整个Web应用程序
16、字符串编码：GBK 、UTF-8
17、什么是Ajar
异步js与XML。
结合了java技术、js技术、xml技术。 客户端技术
功能：在不刷新页面的情况下通过与服务器进行少量的数据交互来提高页面的交互性，减少响应时间，改善用户体验
18、cookie和session的区别：
Session：指用来在客户端与服务器端之间保持状态的解决方案以及存储结构。
Cookie:由Web服务器保存在用户浏览器上的小文件。
19、web服务器：接收来自于客户端的请求，然后把对请求的处理结果反馈个客户端
两大web服务器：IIS Apache。
20、web容器：TomcatJBoss
负责给servlet提供http请求和响应对象，调用doGet（）过doPost（）方法来处理用户请求。
21、EJB的类别：
1）session Bean（会话Bean）实现服务器端的业务逻辑，协调Bean之间的交互
2）Entity Bean（实体Bean）资料组件 代表数据库中的记录
3）Message Bean（消息驱动 Bean)处理异步消息，一般不是由用户来调用的
22、EJB与Javabean的异同：
1）EJB:主要用于服务器端的开发，Javabean主要用在客户端的开发。
2）EJB组件可以部署在EJB容器中，不直接访问组件，而是通过容器访问，javabean不可部署
3）EJB是分布式对象，可以被远程调用，javabean不是，只能在内部被访问
23、EJB的角色：
1）Enterprise Bean Provider（企业级组件开发者）
2）Application Assembler（应用组合者）
3）EJB Deployer（EJB部署者)
4）EJB Sever Provider（EJB服务器提供者）
5）EJB Container Provider(EJV容器提供者）
6）System Administrator(系统管理员）
24、数据库连接池的工作机制：
原因：
1）建立数据库是非常耗时的操作
2）数据库连接个数是有限的
数据库连接池负责分配 管理 释放数据库连接。当客户需要访问数据库是，就可以直接从池中获取数据库的连接，而不用去创建连接，同时标志为忙状态。
25、JAVAEE开发的调优方法：
1）优化设计
2）尽可能使用数据库连接
3）使用框架
4）优化I/O
5）优化查询
26、struts框架的优点：
1）实现表现和逻辑的分离
2）提供页面导航功能
3）提供表单验证
4）提供数据库连接池
5）提供了异常处理机制
6）支持国际化
27、数据验证分为：
1）表单验证
2)业务逻辑验证
28、国际化：
程序在不修改内部代码的情况下，根据不同地区显示相应的界面
29、什么事控制反转：
也称依赖注入，一种降低对象之间耦合关系的设计思想。
使上层不仔依赖于下层的接口，调用者（子)决定被调用者(父）。通过注入一个实例化的对象来实现解耦和目的。
30、Spring框架
提供了对轻量级loc的良好支持，也提供对AOP技术的非常好的封装。
31、Hibernate框架，持久层框架
实现Java对象与关系数据库记录的映射，简化开发人员访问数据库的流程，提高软件开发的效率
任何使用到JDBC的都可以使用Hibernata
提高性能方法：
1）延迟加载
2）缓存技术
3）优化查询语句
32、实现分页：
1)Hibernate自带的分页机制
2)用SQL语句实现，使用limit关键字
33、SSH：
struts实现视图部分
Hibernate实现模型部分
Spring实现业务部分
采用SSH框架，不仅能实现视图、控制器与模型的彻底分离，而且还能实现业务逻辑与数据持久层的分离

4. java基础知识有那些

基础语法:
jdk的安装和环境配置,
变量和常量,
条件判断语句,
循环语句,
循环控制语句
方法和数组:
方法的定义和调用,
方法的重载和递归操作,
数组的定义和初始化,
数组的遍历和常见的方法调用
面向对象:
类的定义和对象的创建,
对象的实例化流程,
抽象,
封装,
继承,
多态思想,
接口的设计和实现
异常和常用类:
异常机制和异常体系,
try-catch语句,
throw和throws关键字,
自定义异常,
String,
StringBuffer,
StringBuilder类,
System,
Runtime类,
Math,
Random,
BigDecimal类
多线程:
并行和并发,
进程和线程,
线程的启动方式,
线程安全的处理方式,
同步锁和死锁的概述,
线程的生命周期和状态,
联合线程和后台线程,
线程优先级和线程礼让和定时器
集合框架:
ArrayList和LinkedList,
HashSet和TreeSet,
LinkedHashSet,
Comparable接口和Comparator接口,
HashMap和TreeMap,
LinkedhashMap,
泛型的定义和使用
IO和网络编程:
File类的基本使用,
FilenameFilter接口的使用,
IO流的体系结构,
字节流和字符流的使用,
缓冲流,标准流,打印流,转换流,数据流,管道流,对象流,
对象序列化和发序列化,
字符编码和解码,
Properties类加载资源,
RandomAccessFile类,
NIO操作,
网络概述和分层模型,
网络三要素,
TCP和UDP协议和编程

5. java基础知识

7.Swing组件中常用于提示的组件叫 面板容器 。
8.AWT基本组件类有（至少写出两个）： Dialog与FileDialogTextArea等。
9.如果一个对象未被实例化就使用了，这会导致空指针异常。中文称为数组小标越界的异常。
10.Java异常处理机制一般是通过语句try-catch来处理。
11. 子类想要访问父类的同名方法，应当使用super关键字。
12. 网络常见协议有 TCP 、UDP、Telnet,FTP,POP3等。

6. Java基础有哪些知识点

java的运行环境是Eclipse..基础就是要熟练掌握和运用以下知识点:1.变量.数据类型.运算符.2.条件结构(if-else和switch)3.循环结构(while/do-while/for)4.OOP思想(面向对象编程)----类和对象5.数组和字符串以上这些都是最基础的了..如果有漏掉的就请其他兄弟补充一下吧..

7. JAVA基础包括那些知识

1、 对象的初始化
(1) 非静态对象的初始化
在创建对象时，对象所在类的所有数据成员会首先进行初始化。
基本类型：int型，初始化为0。
如果为对象：这些对象会按顺序初始化。
※在所有类成员初始化完成之后，才调用本类的构造方法创建对象。
构造方法的作用就是初始化。
(2) 静态对象的初始化
程序中主类的静态变量会在main方法执行前初始化。
不仅第一次创建对象时，类中的所有静态变量都初始化，并且第一次访问某类（注意此时
未创建此类对象）的静态对象时，所有的静态变量也要按它们在类中的顺序初始化。
2、 继承时，对象的初始化过程
(1) 主类的超类由高到低按顺序初始化静态成员，无论静态成员是否为private。
(2) 主类静态成员的初始化。
(3) 主类的超类由高到低进行默认构造方法的调用。注意，在调用每一个超类的默认构造
方法前，先进行对此超类进行非静态对象的初始化。
(4) 主类非静态成员的初始化。
(5) 调用主类的构造方法。
3、 关于构造方法
(1) 类可以没有构造方法，但如果有多个构造方法，就应该要有默认的构造方法，否则在继承此类时，需要在子类中显式调用父类的某一个非默认的构造方法了。
(2) 在一个构造方法中，只能调用一次其他的构造方法，并且调用构造方法的语句必须是
第一条语句。
4、 有关public、private和protected
(1) 无public修饰的类，可以被其他类访问的条件是：a.两个类在同一文件中，b.两个类
在同一文件夹中，c.两个类在同一软件包中。
(2) protected：继承类和同一软件包的类可访问。
(3) 如果构造方法为private，那么在其他类中不能创建该类的对象。
5、 抽象类
(1) 抽象类不能创建对象。
(2) 如果一个类中一个方法为抽象方法，则这个类必须为abstract抽象类。
(3) 继承抽象类的类在类中必须实现抽象类中的抽象方法。
(4) 抽象类中可以有抽象方法，也可有非抽象方法。抽象方法不能为private。
(5) 间接继承抽象类的类可以不给出抽象方法的定义。
6、 final关键字
(1) 一个对象是常量，不代表不能转变对象的成员，仍可以其成员进行操作。
(2) 常量在使用前必须赋值，但除了在声明的同时初始化外，就只能在构造方法中初始化
。
(3) final修饰的方法不能被重置（在子类中不能出现同名方法）。
(4) 如果声明一个类为final，则所有的方法均为final，无论其是否被final修饰，但数据
成员可为final也可不是。
7、 接口interface （用implements来实现接口）
(1) 接口中的所有数据均为 static和final即静态常量。尽管可以不用这两个关键字修饰
，但必须给常量赋初值。
(2) 接口中的方法均为public，在实现接口类中，实现方法必须可public关键字。
(3) 如果使用public来修饰接口，则接口必须与文件名相同。
8、 多重继承
(1) 一个类继承了一个类和接口，那么必须将类写在前面，接口写在后面，接口之间用逗
号分隔。
(2) 接口之间可多重继承，注意使用关键字extends。
(3) 一个类虽只实现了一个接口，但不仅要实现这个接口的所有方法，还要实现这个接口
继承的接口的方法，接口中的所有方法均须在类中实现。
9、 接口的嵌入
(1) 接口嵌入类中，可以使用private修饰。此时，接口只能在所在的类中实现，其他类不
能访问。
(2) 嵌入接口中的接口一定要为public。
10、类的嵌入
(1) 类可以嵌入另一个类中，但不能嵌入接口中。
(2) 在静态方法或其他方法中，不能直接创建内部类对象，需通过手段来取得。
手段有两种：
class A {
class B {}
B getB() {
B b = new B();
return b;
}
}
static void m() {
A a = new A();
A.B ab = a.getB(); // 或者是 A.B ab = a.new B();
}
(3) 一个类继承了另一个类的内部类，因为超类是内部类，而内部类的构造方法不能自动
被调用，这样就需要在子类的构造方法中明确的调用超类的构造方法。
接上例：
class C extends A.B {
C() {
new A().super(); // 这一句就实现了对内部类构造方法的调用。
}
}
构造方法也可这样写：
C(A a) {
a.super();
} // 使用这个构造方法创建对象，要写成C c = new C(a); a是A的对象。
11、异常类
JAVA中除了RunTimeException 类，其他异常均须捕获或抛出。
至于数据库，WEB，JSP，JS之类的那是高级部分了

8. java基础知识 有哪些知识点 要全面 不用详细。。

第2章 一切都是对象
2.1 用句柄操纵对象
2.2 必须创建所有对象
2.2.1 保存在什么地方
2.2.2 特殊情况：主类型
2.2.3 Java中的数组
2.3 绝对不要清除对象
2.3.1 作用域
2.3.2 对象的作用域
2.4 新建数据类型：类
2.4.1 字段和方法
2.5 方法、自变量和返回值
2.5.1 自变量列表
2.6 构建Java程序
2.6.1 名字的可见性
2.6.2 使用其他组件
2.6.3 static关键字
2.7 我们的第一个Java程序
2.8 注释和嵌入文档
2.8.1 注释文档
2.8.2 具体语法
2.8.3 嵌入HTML
2.8.4 @see：引用其他类
2.8.5 类文档标记
2.8.6 变量文档标记
2.8.7 方法文档标记
2.8.8 文档示例
2.9 编码样式
2.10 总结
2.11 练习

第3章 控制程序流程
3.1 使用Java运算符
3.1.1 优先级
3.1.2 赋值
3.1.3 算术运算符
3.1.4 自动递增和递减
3.1.5 关系运算符
3.1.6 逻辑运算符
3.1.7 按位运算符
3.1.8 移位运算符
3.1.9 三元if-else运算符
3.1.10 逗号运算符
3.1.11 字串运算符+
3.1.12 运算符常规操作规则
3.1.13 造型运算符
3.1.14 Java没有“sizeof”
3.1.15 复习计算顺序
3.1.16 运算符总结
3.2 执行控制
3.2.1 真和假
3.2.2 if-else
3.2.3 反复
3.2.4 do-while
3.2.5 for
3.2.6 中断和继续
3.2.7 切换
3.3 总结
3.4 练习

第4章 初始化和清除
4.1 由构建器保证初始化
4.2 方法过载
4.2.1 区分过载方法
4.2.2 主类型的过载
4.2.3 返回值过载
4.2.4 默认构建器
4.2.5 this关键字
4.3 清除：收尾和垃圾收集
4.3.1 finalize()用途何在
4.3.2 必须执行清除
4.4 成员初始化
4.4.1 规定初始化
4.4.2 构建器初始化
4.5 数组初始化
4.5.1 多维数组
4.6 总结
4.7 练习

第5章 隐藏实施过程
5.1 包：库单元
5.1.1 创建独一无二的包名
5.1.2 自定义工具库
5.1.3 利用导入改变行为
5.1.4 包的停用
5.2 Java访问指示符
5.2.1 “友好的”
5.2.2 public：接口访问
5.2.3 private：不能接触
5.2.4 protected：“友好的一种”
5.3 接口与实现
5.4 类访问
5.5 总结
5.6 练习

第6章 类再生
6.1 合成的语法
6.2 继承的语法
6.2.1 初始化基础类
6.3 合成与继承的结合
6.3.1 确保正确的清除
6.3.2 名字的隐藏
6.4 到底选择合成还是继承
6.5 protected
6.6 递增开发
6.7 上溯造型
6.7.1 何谓“上溯造型”？
6.8 final关键字
6.8.1 final数据
6.8.2 final方法
6.8.3 final类
6.8.4 final的注意事项
6.9 初始化和类装载
6.9.1 继承初始化
6.10 总结
6.11 练习

第7章 多形性
7.1 上溯造型
7.1.1 为什么要上溯造型
7.2 深入理解
7.2.1 方法调用的绑定
7.2.2 产生正确的行为
7.2.3 扩展性
7.3 覆盖与过载
7.4 抽象类和方法
7.5 接口
7.5.1 Java的“多重继承”
7.5.2 通过继承扩展接口
7.5.3 常数分组
7.5.4 初始化接口中的字段
7.6 内部类
7.6.1 内部类和上溯造型
7.6.2 方法和作用域中的内部类
7.6.3 链接到外部类
7.6.4 static内部类
7.6.5 引用外部类对象
7.6.6 从内部类继承
7.6.7 内部类可以覆盖吗？
7.6.8 内部类标识符
7.6.9 为什么要用内部类：控制框架
7.7 构建器和多形性
7.7.1 构建器的调用顺序
7.7.2 继承和finalize()
7.7.3 构建器内部的多形性方法的行为
7.8 通过继承进行设计
7.8.1 纯继承与扩展
7.8.2 下溯造型与运行期类型标识
7.9 总结
7.10 练习

第8章 对象的容纳
8.1 数组
8.1.1 数组和第一类对象
8.1.2 数组的返回
8.2 集合
8.2.1 缺点：类型未知
8.3 枚举器（反复器）
8.4 集合的类型
8.4.1 Vector
8.4.2 BitSet
8.4.3 Stack
8.4.4 Hashtable
8.4.5 再论枚举器
8.5 排序
8.6 通用集合库
8.7 新集合
8.7.1 使用Collections
8.7.2 使用Lists
8.7.3 使用Sets
8.7.4 使用Maps
8.7.5 决定实施方案
8.7.6 未支持的操作
8.7.7 排序和搜索
8.7.8 实用工具
8.8 总结
8.9 练习

第9章 违例差错控制
9.1 基本违例
9.1.1 违例自变量
9.2 违例的捕获
9.2.1 try块
9.2.2 违例控制器
9.2.3 违例规范
9.2.4 捕获所有违例
9.2.5 重新“掷”出违例
9.3 标准Java违例
9.3.1 RuntimeException的特殊情况
9.4 创建自己的违例
9.5 违例的限制
9.6 用finally清除
9.6.1 用finally做什么
9.6.2 缺点：丢失的违例
9.7 构建器
9.8 违例匹配
9.8.1 违例准则
9.9 总结
9.10 练习

第10章 Java IO系统
10.1 输入和输出
10.1.1 InputStream的类型
10.1.2 OutputStream的类型
10.2 增添属性和有用的接口
10.2.1 通过FilterInputStream从InputStream里读入数据
10.2.2 通过FilterOutputStream向OutputStream里写入数据
10.3 本身的缺陷：RandomAccessFile
10.4 File类
10.4.1 目录列表器
10.4.2 检查与创建目录
10.5 IO流的典型应用
10.5.1 输入流
10.5.2 输出流
10.5.3 快捷文件处理
10.5.4 从标准输入中读取数据
10.5.5 管道数据流
10.6 StreamTokenizer
10.6.1 StringTokenizer
10.7 Java 1.1的IO流
10.7.1 数据的发起与接收
10.7.2 修改数据流的行为
10.7.3 未改变的类
10.7.4 一个例子
10.7.5 重定向标准IO
10.8 压缩
10.8.1 用GZIP进行简单压缩
10.8.2 用Zip进行多文件保存
10.8.3 Java归档（jar）实用程序
10.9 对象串联
10.9.1 寻找类
10.9.2 序列化的控制
10.9.3 利用“持久性”
10.10 总结
10.11 练习

第11章 运行期类型鉴定
11.1 对RTTI的需要
11.1.1 Class对象
11.1.2 造型前的检查
11.2 RTTI语法
11.3 反射：运行期类信息
11.3.1 一个类方法提取器
11.4 总结
11.5 练习

第12章 传递和返回对象
12.1 传递句柄
12.1.1 别名问题
12.2 制作本地副本
12.2.1 按值传递
12.2.2 克隆对象
12.2.3 使类具有克隆能力
12.2.4 成功的克隆
12.2.5 Object.clone()的效果
12.2.6 克隆合成对象
12.2.7 用Vector进行深层复制
12.2.8 通过序列化进行深层复制
12.2.9 使克隆具有更大的深度
12.2.10 为什么有这个奇怪的设计
12.3 克隆的控制
12.3.1 副本构建器
12.4 只读类
12.4.1 创建只读类
12.4.2 “一成不变”的弊端
12.4.3 不变字串
12.4.4 String和StringBuffer类
12.4.5 字串的特殊性

9. JAVA基础知识

实现排序有好几种，我随便写一种给你参考下吧。
EXP：实现Comparator接口来比较对象，实现排序功能。
1.定义一个学生类Student .java，须重写toString()方法。
public class Student {
private String name;
private int age;
private int score;
public Student(String name, int age, int score) {
super();
this.name = name;
this.age = age;
this.score = score;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public int getScore() {
return score;
}
public void setScore(int score) {
this.score = score;
}
public String toString() {
return "Student [name=" + name + ", age=" + age + ", score=" + score
+ "]";
}
}
2.写一个比较类MyComparator.java，须实现Comparator接口
public class MyComparator implements Comparator<Student> {
public int compare(Student s1, Student s2) {
if (s1.getScore() > s2.getScore()) {
return 1;
} else if (s1.getScore() < s2.getScore()) {
return -1;
} else {
return 0;
}
}
}
3.写一个测试类Test.java
public class Test {
public static void main(String args[]) throws IOException {
new Test().sort();
}

private void sort() {
Student s1 = new Student("小明", 20, 150);
Student s2 = new Student("小艾", 20, 100);
Student s3 = new Student("小白", 20, 190);
Student s4 = new Student("小黑", 20, 90);
Student s5 = new Student("小黄", 20, 130);
List<Student> list = new ArrayList<Student>();
list.add(s1);
list.add(s2);
list.add(s3);
list.add(s4);
list.add(s5);
Collections.sort(list, new MyComparator());
System.out.println(list);
}
}
4.输出结果：
[Student [name=小黑, age=20, score=90],
Student [name=小艾, age=20, score=100],
Student [name=小黄, age=20, score=130],
Student [name=小明, age=20, score=150],
Student [name=小白, age=20, score=190]]