JAVAEE是什么?与JAVA 有什么区别?

发布网友 发布时间：2022-04-23 13:13

我来回答

共13个回答

懂视网 时间：2022-05-01 10:58

Class.forName(“com.mysql.jdbc.Driver”);

          第二步：获取Connection连接对象

                                Connection conn=DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/cms","root","root")

          第三步:预处理SQL语句，并返回一个PreparedStatement预处理对象。

                                PreparedStatement pstmt=conn.prepareStatement(sql);

          第四步:如果有占位符使用预处理对象通过一些set方法给占位符赋值

                              pstmt.setString("name",username)

          第五步:执行SQL语句，执行SQL语句方法有两种一种是没有结果集返回(一般用于:增、删、改)，另一种是有结果集(查询)返回的

                             int executeUpdate();增 删  该
             Result executeQuery();查

          第六步:有结果ResultSet处理结果集

          第七步:释放资源主要需要关闭Connection连接对象，PreparedStatement预处理SQL语句对象，ResultSet结果集

                          注意关闭的顺序：先创建的后关闭

                             rs.close();

                             pstmt.close();

                             conn.close();

一般基本的JDBC对数据库操作都会经过以上几个步骤，可能实际步骤没那么多，自己细化了一下。现在我们可以来想一下，我们最原始的数据库JDBC的操作，每一次的增删改查都会涉及到以上步骤，有的人就说这还不简单把每一个操作定义一个方法，把代码粘贴复制改下就可以。这样我们会发现会有大量的代码重复和冗余。相信很多人都很容易想到将相同的代码抽取出来，然后下次使用的时候直接调用即可。好的就是这样我们需要把哪些代码抽取封装呢？其实很简单，我们不难发现无论是增删改查操作，都需要获取连接对象，然后最后都需要去释放资源，我们就不妨把这些代码给抽取出来然后在增删改查方法中去引用这些代码即可。我们就可以定义个ConnectionFactory类，然后在其中定义一个静态方法用于返回一个Connection对象，再定义一个close方法。

 

package com.mikyou.common;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

public class ConnectionFactory {
	/**
	 * 获取连接
	 * */
	private static String driver;
	private static String url;
	private static String user;
	private static String password;
	/**
	 * @Mikyou
	 * 使用静态代码块，来提前初始化一些参数，
	 * 我们都知道静态代码块中的代码是在ConnectionFactory类在方法区中加载的时候，就开始加载
	 * 所以可以起到一个预加载和与初始化的一个作用
	 * */
	static{//为了扩展
		driver="com.mysql.jdbc.Driver";
		url="jdbc:mysql://127.0.0.1:3306/cms";
		user="root";
		password="root";
	}
	/**
	 * @Mikyou
	 * 获取连接对象
	 * */
	public static Connection getConnection() throws Exception{
		Class.forName(driver);
		return DriverManager.getConnection(url,user,password);
	}
	/**
	 * @Mikyou
	 * 用于释放资源
	 * @param rs
	 * @param pstmt
	 * @param conn
	 * 首先需要判断这些参数是否为空，因为有些操作并且全都涉及这三个对象
	 * 例如增加操作就不涉及ResultSet rs
	 * */
	public static void close(ResultSet rs,PreparedStatement pstmt,Connection conn) throws SQLException{
		if (rs!=null) {
			rs.close();
		}
		if (pstmt!=null) {
			pstmt.close();
		}
		if (conn!=null) {
			conn.close();
		}
	}
}

然而、我们通过上一步只是简化一部分而已，这只是封装的第一步，接下来才是真正的JDBC的封装。在封装之前我们先来思考几个问题，在使用JDBC对数据库一般基本常用几个方法是哪些，有的人说4个实际上在项目开发的时候至少都有5个方法:add  delete update queryOne  queryAll.好我们先明确了有5个方法那么接下来我们再来分析一下这5个方法有什么相同点和不同点，或者说哪些方法可以化为一类，哪些方法化为另一类。我很容易发现并可以很快分类：add,delete,update（无结果集）queryOne(有一个结果集) queryAll(有不确定个数的结果集)，所以根据这三个分类我们就对应在JDBCTemplate模板类中的三个方法，用同一个方法处理同一类的问题。分别对应了模板类中的

update(无结果集) findOne(返回一个结果集) findAll(返回不确定个数结果集)。

  有了这三个方法的确立，我们再去深入这三个方法:

      第一个update方法，如何利用定义一个通用的update方法去统一add,delete,update三个操作呢。那就得看这三个操作方法的异同点，首先我们得出这三个方法的执行的sql语句是不一样的，所以sql语句需要通过外部调用传入，然后会发现在处理sql语句占位符也就是给占位符赋值的时候是不一样的，所以也需要外部调用的时候传入，但是随之而来的一个问题是给占位符赋值通过外部传入的话怎么传，因为我们知道处理占位符时的类型和占位符的个数是不一样的，那么就可以得出处理占位符的类型不确定以及个数不确定结论，所以相信大家到这里都应该猜到了怎么传？其实由多种方式可以传，可以使用集合加Object类型泛型List<Object>或者Object数组Object[],然后传进来就是需要给占位符赋值，我们可以去遍历这个集合或者数组然后利用setObject(key,value)来处理占位符,那么实际上第一个方法分析好了，封装也就很容易了。封装如下:

	public void update(String sql, Object[] agrs){
		try {
			Connection conn=null;
			PreparedStatement pstmt=null;
			try {
				conn=ConnectionFactory.getConnection();//获取连接对象
				pstmt=conn.prepareStatement(sql);//预处理sql
				for (int i = 0; i < agrs.length; i++) {//处理占位符
					pstmt.setObject(i+1, agrs[i]);//注意：为什么是+1，JDBC中设置占位符序号是从1开始的，特例，以后Hibernate中都是从0开始的
				}
				pstmt.executeUpdate();//由于不需要返回结果集，所以直接使用executeUpdate
			} finally {
				ConnectionFactory.close(null, pstmt, conn);//关闭连接
			}
		} catch (Exception e) {
		}
	}

    第二个方法和第三个方法相对第一个方法稍微就要麻烦一些了，为什么呢？因为它有结果集返回呀，我们怎么去得到这些结果集并去处理这些结果集呢？如果学Android或者学过JavaSE中的GUI编程朋友就很容易想到利用自定义监听器的回调方法返回结果集并在回调方法中去处理这些结果集。因为在Android或者GUI对一些UI控件都会设有一个监听器里面会有回调方法，通过回调方法的参数就可以传值了，类似于Android中的OnClickListener接口。所以我们可以仿照这样的一个接口回调机制，将我们的结果集作为回调方法参数传递即可。但是这里还需做一点修改就是我们虽然可以传递结果集，但是我们结果集也分为两种情况:第一只返回一个结果集，第二则返回不确定个数的结果集，怎么解决这个问题呢？因为我们的定义的接口每次只返回一个对象，所以对于不确定结果集的话，可以通过循环多次返回得到多个对象，并且将多个对象放入到集合中去， 结果集返回的问题解决了，那么接下来再来思考一个问题就是query和queryAll方法的返回值的类型是什么？我们的这个模板方法应该是通用的，适用于不同的Bean类，所以我们很容易就想到了java中的泛型，利用泛型，就可以确定query返回值的类型为T，queryAll返回值的类型为List<T>,这样就可以适用所有的Bean类。

           第一步：自定义一个监听器OnIMapperListener

                         1、先定义一个接口:OnIMapperListener

package com.mikyou.common;

import java.sql.ResultSet;
/**
 * 映射监听器接口
 * */
public interface OnIMapperListener<T>{
	public T mapper(ResultSet rs);//flag标记变量 rs返回的结果集 T表示处理完结果集返回值类型，一般返回值的类型是相应的Bean类型
}

                   2、再到JDBCTemplate模板类中去定义一个OnIMapperListener<T>接口类的引用listener，再去定义一个方法setOnIMapperListener()用于初始化这个OnIMapperListener<T>接口引用，这个是不是很类似Android中的setOnClickListener(),实际上意义是一样的。

	private OnIMapperListener< T> listener;
	public void setOnMapperListener(OnIMapperListener< T> mapper){//初始化映射监听器
		this.listener=mapper;
	}

                 3、封装的queryOne和queryAll方法:

	/**
	 * @Mikyou
	 * queryOne方法
	 * 
	 * */

	public T queryOne(String sql,Object[] agrs){
		T obj=null;
		try {
			Connection conn=null;
			PreparedStatement pstmt=null;
			ResultSet rs=null;
			try {
				conn=ConnectionFactory.getConnection();
				pstmt=conn.prepareStatement(sql);
				for (int i = 0; i < agrs.length; i++) {
					pstmt.setObject(i+1, agrs[i]);
				}
				rs=pstmt.executeQuery();
				if (rs.next()) {
					if (listener!=null) {//表示已经注册了映射监听器了，监听器对象不为空
						obj=listener.mapper(rs);//结果集作为参数传入回调方法中
					}

				}
			} finally {
				ConnectionFactory.close(rs, pstmt, conn);
			}
		} catch (Exception e) {
		}
		return obj;
	}
	/**
	 * @MIkyou
	 * queryAll方法
	 * */
	public List<T> queryAll(String sql,Object[] agrs){
		List<T>list=new ArrayList<T>();
		try {
			Connection conn=null;
			PreparedStatement pstmt=null;
			ResultSet rs=null;
			try {
				conn=ConnectionFactory.getConnection();
				pstmt=conn.prepareStatement(sql);
				for (int i = 0; i < agrs.length; i++) {
					pstmt.setObject(i+1, agrs[i]);
				}
				rs=pstmt.executeQuery();
				while (rs.next()) {
					if (listener!=null) {//表示已经注册了映射监听器了，监听器对象不为空
						T obj=listener.mapper(rs);//结果集作为参数传入回调方法中
						list.add(obj);			
					}

				}
			} finally {
				ConnectionFactory.close(rs, pstmt, conn);
			}
		} catch (Exception e) {
		}
		return list;
	}

最后附上完整的JDBCTemplate模板类以后可以直接拿到项目中使用:

<pre name="code" class="java">package com.mikyou.common;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;

public class JDBCTemplate<T> {
	private OnIMapperListener< T> listener;
	public void setOnMapperListener(OnIMapperListener< T> mapper){//初始化映射监听器
		this.listener=mapper;
	}
	public void update(String sql, Object[] agrs){
		try {
			Connection conn=null;
			PreparedStatement pstmt=null;
			try {
				conn=ConnectionFactory.getConnection();//获取连接对象
				pstmt=conn.prepareStatement(sql);//预处理sql
				for (int i = 0; i < agrs.length; i++) {//处理占位符
					pstmt.setObject(i+1, agrs[i]);
				}
				pstmt.executeUpdate();//由于不需要返回结果集，所以直接使用executeUpdate
			} finally {
				ConnectionFactory.close(null, pstmt, conn);//关闭连接
			}
		} catch (Exception e) {
		}
	}
	/**
	 * @Mikyou
	 * queryOne方法
	 * 
	 * */

	public T queryOne(String sql,Object[] agrs){
		T obj=null;
		try {
			Connection conn=null;
			PreparedStatement pstmt=null;
			ResultSet rs=null;
			try {
				conn=ConnectionFactory.getConnection();
				pstmt=conn.prepareStatement(sql);
				for (int i = 0; i < agrs.length; i++) {
					pstmt.setObject(i+1, agrs[i]);
				}
				rs=pstmt.executeQuery();
				if (rs.next()) {
					if (listener!=null) {//表示已经注册了映射监听器了，监听器对象不为空
						obj=listener.mapper(rs);//结果集作为参数传入回调方法中
					}

				}
			} finally {
				ConnectionFactory.close(rs, pstmt, conn);
			}
		} catch (Exception e) {
		}
		return obj;
	}
	/**
	 * @MIkyou
	 * queryAll方法
	 * */
	public List<T> queryAll(String sql,Object[] agrs){
		List<T>list=new ArrayList<T>();
		try {
			Connection conn=null;
			PreparedStatement pstmt=null;
			ResultSet rs=null;
			try {
				conn=ConnectionFactory.getConnection();
				pstmt=conn.prepareStatement(sql);
				for (int i = 0; i < agrs.length; i++) {
					pstmt.setObject(i+1, agrs[i]);
				}
				rs=pstmt.executeQuery();
				while (rs.next()) {
					if (listener!=null) {//表示已经注册了映射监听器了，监听器对象不为空
						T obj=listener.mapper(rs);//结果集作为参数传入回调方法中
						list.add(obj);			
					}

				}
			} finally {
				ConnectionFactory.close(rs, pstmt, conn);
			}
		} catch (Exception e) {
		}
		return list;
	}

}

我们终于把通用的JDBCTemplate模板给造好了，质量好不好我们得来检验检验，我们写了简单的测试来检验模板类封装成功还是失败。

我们一般在哪使用这个JDBCTemplate类呢？或者怎么使用去使用这个JDBCTemplate类呢？我们一般在DAO层使用，DAO一般是对数据库的各种增删改查操作，至于这个项目架构和封层等会即将讲解。我们就写一个CustomerDAO类去实现我们监听器，并重写回调方法mapper方法，该方法中的参数就是回调返回的结果集，并用Customer这个Bean类作为泛型类型。

package com.mikyou.dao;


import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;

import com.mikyou.bean.Customer;
import com.mikyou.common.JDBCTemplate;
import com.mikyou.common.OnIMapperListener;
/**
 * @Mikyou
 * JDBCTemplate：<--->JDBC模板类
 * 
 * */
public class CustomerDAO implements OnIMapperListener<Customer>{
	private JDBCTemplate<Customer>temp;
	public CustomerDAO() {
		 temp=new JDBCTemplate<Customer>();
		 temp.setOnMapperListener(this);//给CustomerDAO注册映射监听器
	}
	/**
	 * 以下三个方法都有一个共同的特点就是无需带有返回结果集，所以直接在JDBCTemplate模板类中直接封装成一个update方法即可
	 * */
	public void save(Customer customer) throws SQLException{
		String sql="insert into tb1_customer(name,gender,telephone,address) values(?,?,?,?)";
		Object[] agrs={customer.getName(),customer.getGender(),customer.getTelephone(),customer.getAddress()};
		temp.update(sql, agrs);
	}
	public void update(Customer customer){
		String sql="update tb1_customer set name=?,gender=?,telephone=?,address=? where id=?";
		Object[] agrs={customer.getName(),customer.getGender(),customer.getTelephone(),customer.getAddress(),customer.getId()};
		temp.update(sql, agrs);
	}
	public void delete(long id){
		String sql="delete from tb1_customer where id=?";
		Object[] agrs={id};
		temp.update(sql, agrs);
	}

	
	public Customer findByName(String name){
		String sql="select * from tb1_customer where name=?";
		Object[] args={name};
		Customer customer=temp.queryOne(sql, args);
		return customer; 
	}
	public List<Customer> findAll(){
		String sql="select * from tb1_customer";
		Object[] args={};
		return temp.queryAll(sql, args);
	}
	/**
	 * @Mikyou
	 * 具体实现相应的回调方法
	 * @param rs 回调返回的结果集
	 * @deprecated:处理结果集 并且返回的类型是我们的Bean类型Customer
	 * */
	@Override
	public Customer mapper(ResultSet rs) {
		Customer customer=null;
		try {
			Long id=rs.getLong("id");
			String name=rs.getString("name");
			String gender=rs.getString("gender");
			String address=rs.getString("address");
			String telephone=rs.getString("telephone");
			customer=new Customer(id, name, gender, telephone, address);
		} catch (SQLException e) {
			e.printStackTrace();
		}
		return customer;
	}
}

接下来我们写一个DaoTest测试类测试一下:

增加操作:

	private void add() {
		CustomerDAO customerDAO=new CustomerDAO();
		try {
			Customer customer=new Customer(1L, "Mikyou", "男", "123456789", "中国");
			customerDAO.save(customer);
			Customer customer2=new Customer(2L, "Alice", "女", "123456789", "美国");
			customerDAO.save(customer2);
		} catch (SQLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	
	}

运行结果:

更新操作:

	private void update() {
		// TODO Auto-generated method stub
		CustomerDAO customerDAO=new CustomerDAO();
		customerDAO.update(new Customer(2L, "Bob", "男", "123456789", "英国"));
	}

运行结果:

查询确定某一个：

private void findOne() {
		// TODO Auto-generated method stub
		CustomerDAO customerDAO=new CustomerDAO();
		Customer customer=customerDAO.findByName("Bob");
		System.out.println(customer.toString());
	}

查询多个:

	private void findAll() {
		// TODO Auto-generated method stub
		CustomerDAO customerDAO=new CustomerDAO();
		List<Customer> customers=customerDAO.findAll();
		for (Customer customer : customers) {
			System.out.println(customer.toString());
		}

	}

删除操作:

	private void delete() {
		// TODO Auto-generated method stub
		CustomerDAO customerDAO=new CustomerDAO();
		customerDAO.delete(1L);
	}

DaoTest测试类:

package com.mikyou.test;

import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

import com.mikyou.bean.Customer;
import com.mikyou.dao.CustomerDAO;
import com.sun.org.apache.bcel.internal.util.SecuritySupport;

public class DaoTest {

	public static void main(String[] args) {
 //new DaoTest().add();//增
 new DaoTest().delete();//删
 // new DaoTest().update();//改
 //new DaoTest().findOne();//查询具体某一个
 // new DaoTest().findAll();//查询一个集合
	}

	private void findAll() {
		// TODO Auto-generated method stub
		CustomerDAO customerDAO=new CustomerDAO();
		List<Customer> customers=customerDAO.findAll();
		for (Customer customer : customers) {
			System.out.println(customer.toString());
		}

	}

	private void findOne() {
		// TODO Auto-generated method stub
		CustomerDAO customerDAO=new CustomerDAO();
		Customer customer=customerDAO.findByName("Bob");
		System.out.println(customer.toString());
	}

	private void update() {
		// TODO Auto-generated method stub
		CustomerDAO customerDAO=new CustomerDAO();
		customerDAO.update(new Customer(2L, "Bob", "男", "123456789", "英国"));
	}

	private void delete() {
		// TODO Auto-generated method stub
		CustomerDAO customerDAO=new CustomerDAO();
		customerDAO.delete(1L);
	}

	private void add() {
		CustomerDAO customerDAO=new CustomerDAO();
		try {
			Customer customer=new Customer(1L, "Mikyou", "男", "123456789", "中国");
			customerDAO.save(customer);
			Customer customer2=new Customer(2L, "Alice", "女", "123456789", "美国");
			customerDAO.save(customer2);
		} catch (SQLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	
	}

}

到这里JDBCTemplate模板类简单封装就到这了，是不是感觉比以前直接写一大堆重复冗余的代码要好一点呢？

下面接着继续讲下我们JavaEE的包该如何建以及整个JavaEE项目的分层，其实分层每个人看起来多多少少有那么不一样，但是总体分类是一样的。

主要有Service层(抽象接口层和接口实现层)，DAO层(数据控制层)，Web层(表现层)通过这些分层降低代码之间耦合度，实现数据和视图和业务逻辑层分开。

到这里就结束了，下面将继续介绍SSH三大框架，初学JavaEE，上面博客难免出一些问题，还请多多指正。

浅谈JavaEE中的JDBC模板类的封装实现以及合理的建立项目包结构(一)

标签：

热心网友 时间：2022-05-01 08:06

AVAEE是指java enterprise edition，java企业版，多用于企业级开发，包括web开发等等很多组建；

Java和JavaEE区别：

1. Java是一种可以撰写跨平台应用软件的面向对象的程序设计语言。Java 技术具有卓越的通用性、高效性、平台移植性和安全性，广泛应用于PC、数据中心、游戏控制台、科学超级计算机、移动电话和互联网，同时拥有全球最大的开发者专业社群。正式成立于1995年，广泛应用于人们的生活、工作、娱乐等等方面。

2. Java分为三个版本：Java SE(标准版)、Java EE(企业版)、Java ME(微型版)。其中JavaSE就是大家学JavaEE和JavaME的基础，换而言之学Java先从JavaSE开始，JavaSE 包含了支持 Java Web 服务开发的类，JavaEE是企业最常用的用于企业级开发应用的，Java ME主要是移动段的开发应用。

3. 通过以上，Java和JavaEE的区别在哪，就特别的明显了。那么为什么很多培训主打JavaEE培训呢?是因为JavaEE在Java中，比JavaSE和JavaME应用更加广泛，价值更高，所以很多的培训机构就直接主打JavaEE培训，不过其他两个方面的Java知识也是要大致掌握的。

扩展资料

Java EE是 J2EE的一个新的名称，之所以改名，目的还是让大家清楚J2EE只是Java企业应用.随着WEB和EJB容器概念诞生，使得软件应用业开始担心SUN的伙伴们是否还在Java平台上不断推出翻新的标准框架，致使软件应用业的业务核心组件架构无所适从，从一直以来是否需要EJB的讨论声中说明了这种彷徨。

参考资料

JavaEE——百度百科

热心网友 时间：2022-05-01 09:24

Java分三个版本：Java SE（标准版）、Java EE（企业版）、Java ME（微型版）

其中SE就是大家学的Java基础，EE是公司最常用的用于网站开发（PC端），ME用于移动端开发，现在熟悉的安卓系统就是用JAVAME开发的。

Java既可以被编译，也可以被解释。通过编译器，可以把Java 程序翻译成一种中间代码 - 称为字节码 - 可以被Java解释器 

解释的独立于平台的代码。通过解释器，每条Java字节指令被 分析，然后在计算机上运行。只需编译一次，程序运行时解释 执行。

　　

　　一 有很多教程，叫学了也白搭

这年头，网上的Java教程一堆一堆的，看的我们很多Java宝宝们是眼花缭乱，不知该如何是好，我

当年也是从这个过程走过来的，每天看很多老师的Java教程，听的自己晕头转向的，当然我不是说他们讲错了，他们讲的知识层面的东西是对的，但是很多做

Java教程的老师不善于深入浅出，通俗易懂的来为我们讲解知识，什么是好教程？好教程就是让我们学了之后，有一种豁然开朗的感觉，而不是云深不知处，我

想说的是这种教程，不看也罢，浪费了时间，迷茫了自己。

二 有一种教程叫无论你身处何地，都能现场直播教你

现在很多网上流传的教程都是很多年前的，远远的不适应现在Java新应用的需要，基本上都是一些淘汰货，很多小伙伴们，从网上找这种破烂，学的还不亦乐乎，也是醉了。综上所述，我们很多人学不好Java，是因为 一开始就选择错了，选择不对，努力白费。

为了能够让广大Java学子们在网上学到Java的系统精华知识，通俗易懂的理解这些知识，我们决定现在每天晚上现场直播在网上教大家学习Java，我们的老师，一般的老师不用，我们只让牛掰的老师讲，而你什么都不需要付出，你只需要来我们这个群里听就行，开头的的第一部分是：四二六.，位于中间的第二部分是：396，处于最后一部分的是：284，学习没有任何借口，想强大就要努力，同时这也不是一个单打独斗的时代了，大家在这里一块学习，打拼出属于我们的Java新天地。

三Java新手入门的30个基本概念

在我们学习Java的过程中,掌握其中的基本概念对我们的学习无论是J2SE,J2EE,J2ME都是很重要的,J2SE是Java的基础,所以有必要对其中的基本概念做以归纳,以便大家在以后的学习过程中更好的理解java的精髓,在此我总结了30条基本的概念。 

Java概述: 

目前Java主要应用于中间件的开发(middleware)---处理客户机于服务器之间的通信技术,早期的实践证明,Java不适合pc应用程序的开

发,其发展逐渐变成在开发手持设备,互联*息站,及车载计算机的开发.Java于其他语言所不同的是程序运行时提供了平台的独立性,称许可以在

windows,solaris,linux其他操作系统上使用完全相同的代码.Java的语法与C++语法类似,C++/C程序员很容易掌握,而且

Java是完全的彻底的面向对象的,其中提出了很好的GC(Garbage Collector)垃圾处理机制,防止内存溢出。 

Java的*为我们提出了Java语言的11个关键特质。 

(1)Easy:Java的语法比C++的相对简单,另一个方面就是Java能使软件在很小的机器上运行,基础解释其和类库的支持的大小约为40kb,增加基本的标准库和线程支持的内存需要增加125kb。 

(2)分布式:Java带有很强大的TCP/IP协议族的例程库,Java应用程序能够通过URL来穿过网络来访问远程对象,由于servlet机制的出现,使Java编程非常的高效,现在许多的大的web server都支持servlet。 

(3)OO:面向对象设计是把重点放在对象及对象的接口上的一个编程技术.其面向对象和C++有很多不同,在与多重继承的处理及Java的原类模型。 

(4)健壮特质:Java采取了一个安全指针模型,能减小重写内存和数据崩溃的可能型。 

(5)安全:Java用来设计网路和分布系统,这带来了新的安全问题,Java可以用来构建防病毒和防攻击的System.事实证明Java在防毒这一方面做的很优秀。

(6)中立体系结构:Java编译其生成体系结构中立的目标文件格式可以在很多处理器上执行,编译器产生的指令字节码(Javabytecode)实现此特性,此字节码可以在任何机器上解释执行。 

(7)可移植:Java中对基本数据结构类型的大小和算法都有严格的规定所以可移植很好。 

(8)多线程:Java处理多线程的过程很简单,Java把多线程实现交给底下操作系统或线程程序完成.所以多线程是Java作为服务器端开发语言的流行原因之一。 

(9)Applet和servlet:能够在网页上执行的程序叫Applet,需要支持Java的浏览器很多,而applet支持动态的网页,这是很多其他语言所不能做到的。

　　基本概念:

1.OOP中唯一关系的是对象的接口是什么,就像计算机的销售商她不管电源内部结构是怎样的,他只关系能否给你提供电就行

了,也就是只要知道can or not而不是how and 

why.所有的程序是由一定的属性和行为对象组成的,不同的对象的访问通过函数调用来完成,对象间所有的交流都是通过方法调用,通过对封装对象数据,很大

限度上提高复用率。 

2.OOP中最重要的思想是类,类是模板是蓝图,从类中构造一个对象,即创建了这个类的一个实例(instance)。 

3.封装:就是把数据和行为结合起在一个包中)并对对象使用者隐藏数据的实现过程,一个对象中的数据叫他的实例字段(instance field)。 

4.通过扩展一个类来获得一个新类叫继承(inheritance),而所有的类都是由Object根超类扩展而得,根超类下文会做介绍。 

5.对象的3个主要特点

behavior---说明这个对象能做什么. 

state---当对象施加方法时对象的反映. 

identity---与其他相似行为对象的区分标志. 

每个对象有唯一的indentity 而这3者之间相互影响. 

6.类之间的关系: 

use-a :依赖关系 

has-a :聚合关系 

is-a :继承关系--例:A类继承了B类,此时A类不仅有了B类的方法,还有其自己的方法.(个性存在于共性中) 

7.构造对象使用构造器:构造器的提出,构造器是一种特殊的方法,构造对象并对其初始化。 

例:Data类的构造器叫Data 

new Data()---构造一个新对象,且初始化当前时间. 

Data happyday=new Data()---把一个对象赋值给一个变量happyday,从而使该对象能够多次使用,此处要声明的使变量与对象变量二者是不同的.new返回的值是一个引用。 

构造器特点:构造器可以有0个,一个或多个参数 

构造器和类有相同的名字 

一个类可以有多个构造器 

构造器没有返回值 

构造器总是和new运算符一起使用. 

8.重载:当多个方法具有相同的名字而含有不同的参数时,便发生重载.编译器必须挑选出调用哪个方法。 

9.包(package)Java允许把一个或多个类收集在一起成为一组,称作包,以便于组织任务,标准Java库分为许多包.java.lang java.util java,net等,包是分层次的所有的java包都在java和javax包层次内。 

10.继承思想:允许在已经存在的类的基础上构建新的类,当你继承一个已经存在的类时,那么你就复用了这个类的方法和字段,同时你可以在新类中添加新的方法和字段。 

11.扩展类:扩展类充分体现了is-a的继承关系. 形式为:class (子类) extends (基类)。 

12.多态:在java中,对象变量是多态的.而java中不支持多重继承。 

13.动态绑定:调用对象方法的机制。 

(1)编译器检查对象声明的类型和方法名。 

(2)编译器检查方法调用的参数类型。 

(3)静态绑定:若方法类型为priavte static final 编译器会准确知道该调用哪个方法。 

(4)当程序运行并且使用动态绑定来调用一个方法时,那么虚拟机必须调用x所指向的对象的实际类型相匹配的方法版本。 

(5)动态绑定:是很重要的特性,它能使程序变得可扩展而不需要重编译已存代码。 

14.final类:为防止他人从你的类上派生新类,此类是不可扩展的。 

15.动态调用比静态调用花费的时间要长。 

16.抽象类:规定一个或多个抽象方法的类本身必须定义为abstract。 

例: public abstract string getDescripition 

17.Java中的每一个类都是从Object类扩展而来的。 

18.object类中的equal和toString方法。 

equal用于测试一个对象是否同另一个对象相等。 

toString返回一个代表该对象的字符串,几乎每一个类都会重载该方法,以便返回当前状态的正确表示. 

(toString 方法是一个很重要的方法) 

19.通用编程:任何类类型的所有值都可以同object类性的变量来代替。 

20.数组列表:ArrayList动态数组列表,是一个类库,定义在java.uitl包中,可自动调节数组的大小。 

21.class类 object类中的getclass方法返回ckass类型的一个实例,程序启动时包含在main方法的类会被加载,虚拟机要加载他需要的所有类,每一个加载的类都要加载它需要的类。 

22.class类为编写可动态操纵java代码的程序提供了强大的功能反射,这项功能为JavaBeans特别有用,使用反射Java能支持VB程序员习惯使用的工具。 

能够分析类能力的程序叫反射器,Java中提供此功能的包叫Java.lang.reflect反射机制十分强大. 

1.在运行时分析类的能力。 

2.在运行时探察类的对象。 

3.实现通用数组操纵代码。 

4.提供方法对象。 

而此机制主要针对是工具者而不是应用及程序。 

反射机制中的最重要的部分是允许你检查类的结构.用到的API有: 

java.lang.reflect.Field 返回字段. 

java.reflect.Method 返回方法. 

java.lang.reflect.Constructor 返回参数. 

方法指针:java没有方法指针,把一个方法的地址传给另一个方法,可以在后面调用它,而接口是更好的解决方案。 

23.接口(Interface)说明类该做什么而不指定如何去做,一个类可以实现一个或多个interface。 

24.接口不是一个类,而是对符合接口要求的类的一套规范。 

若实现一个接口需要2个步骤: 

1.声明类需要实现的指定接口。 

2.提供接口中的所有方法的定义。 

声明一个类实现一个接口需要使用implements 关键字 

class actionB implements Comparable 其actionb需要提供CompareTo方法,接口不是类,不能用new实例化一个接口. 

25.一个类只有一个超类,但一个类能实现多个接口。Java中的一个重要接口：Cloneable 

26.接口和回调.编程一个常用的模式是回调模式,在这种模式中你可以指定当一个特定时间发生时回调对象上的方法。 

例:ActionListener 接口监听. 

类似的API有:java.swing.JOptionPane 

java.swing.Timer 

java.awt.Tookit 

27.对象clone:clone方法是object一个保护方法,这意味着你的代码不能简单的调用它。 

28.内部类:一个内部类的定义是定义在另一个内部的类。 

原因是: 

1.一个内部类的对象能够访问创建它的对象的实现,包括私有数据。 

2.对于同一个包中的其他类来说,内部类能够隐藏起来。 

3.匿名内部类可以很方便的定义回调。 

4.使用内部类可以非常方便的编写事件驱动程序。 

29.代理类(proxy): 

1.指定接口要求所有代码 

2.object类定义的所有的方法(toString equals) 

30.数据类型:Java是强调类型的语言,每个变量都必须先申明它都类型,java中总共有8个基本类型.4种是整型,2种是浮点型,一种是字符型,被用于Unicode编码中的字符,布尔型。

热心网友 时间：2022-05-01 10:59

学习Java EE，在开发环境上不建议再用文本编辑器，感觉NetBeans 5.5(目前最高正式版本)很适合初学者，个人也很喜欢NetBeans，如果你喜欢用别的IDE如Eclipse，都没问题，看自己喜欢吧。

1 学习JSP/Servlet

Java EE最高版本目前是5.0版本。

在Java EE中，首先要学习JSP/Servlet(结合Tomcat、MySQL)技术，建议JSP1.2/2.X的知识都要掌握，毕竟现在很多的在用系统都还 是基于JSP1.2，学习JSP，还必须掌握一些外延技术，如：你还得掌握HTML基础知识，最好再掌握些JavaScript(目前正火的AJAX技术 之一)、CSS的技术，而了解XML是必不可少的(至少描述性配置信息是通过XML来描述的)。在学习JSP/Servlet过程中，应该结合学习 JDBC、数据库开发技术，毕竟绝大多数Java Web项目都是和数据库紧密结合的。

2 学习数据库开发技术

这里想重点说一下数据库开发技术，数据库技术是做业务系统必备技能，Java Web开发人员最低程度都应该掌握SQL语句的使用!数据库技术大体可分为DBA技术和数据库开发技术，对于开发而言，应侧重数据库开发技术，而数据库基 本操作，也是要掌握的。常用数据库有DB2、Oracle、SQL Server、MySQL等，你可以结合实际需要，选择一种数据库，并花大力气掌握其开发技术。

记住，学习数据库开发技术和学习Java EE，是相对独立的，你可以在学习JSP/Servlet的同时，学习数据库开发技术(如SQL语句等)，或者先学数据库开发技术，之后再学习JSP/Servlet。

3 学习Java EE其它开发技术

再往后，可以学习一些EJB的知识，目前EJB最新版本是3.0，其和前面的2.X版本相比，有较大不同，考虑到目前EJB 2.X还有很大的应用市场，建议结合学习EJB 2.X/3.0。在学习EJB过程中，应同时掌握一种企业级应用服务器的使用(如 WebSphere、Weblogic、Sun Applcation Server或JBOSS等，目前Sun Applcation Server 9.X和JBOSS都可支持EJB 3.0)。

之后的学习中，再逐渐扩展到其他Java EE技术。

4. 之后

等你对Java EE有些感悟的时候，你自然就会想不断扩展你的知识面，这时候你可以学习Spring、Hibernate，以及各种Web框架(如Struts、JSF、Webwork或是Tapestry等)。

随着技术、经验的不断积累，你会逐步关注分析、设计等更高层次的知识，这时候，你可进一步学习相关的UML、模式等知识(积累了一定经验，你就可以安排自己学习这些知识了)。

热心网友 时间：2022-05-01 12:50

JAVAEE是指java enterprise edition，java企业版，多用于企业级开发，包括web开发等等很多组建；JAVA通常是指java standard edition，Java标准版，就是一般Java程序的开发就可以，可以看作是JAVAEE的子集 。

Java是一门面向对象编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。Java语言作为静态面向对象编程语言的代表，极好地实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程。Java具有简单性、面向对象、分布式、健壮性、安全性、平*立与可移植性、多线程、动态性等特点。Java可以编写桌面应用程序、Web应用程序、分布式系统和嵌入式系统应用程序等。


想了解更多有关编程语言的详情，推荐选择【达内教育】。该机构独创TTS8.0教学系统，企业双选会。达内OMO教学模式，全新升级，线上线下交互学习，满足学生多样化学习需求。对标企业人才标准，制定专业学习计划，囊括主流热点技术。理论知识+学习思维+实战操作，打造完整学习闭环。实战讲师，经验丰富。→感兴趣的话点击此处，免费学习一下

热心网友 时间：2022-05-01 14:58

JAVAEE是指java enterprise edition，java企业版，多用于企业级开发，包括web开发等等很多组建
JAVA通常是指java standard edition，Java标准版，就是一般Java程序的开发就可以，可以看作是JAVAEE的子集

热心网友 时间：2022-05-01 17:23

Java是一门面向对象编程语言，不仅替换为吸收c语言语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。Java语言作为静态面向对象编程语言的代表，极好地实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程 [1] 。ava具有简单性、面向对

象、分布式、健壮性、安全性、可移植性、多线程、动态性等特点 [2] 。Java可以编写桌面应用程序、Web应用程序、分布式系统和嵌入式系统应用程序等 [3] 。20世纪90年代，硬件领域出现了单片式计算机系统，这种价格低廉的系统一出现就立即引起了自动控制领域人员的注意，因为使用它可以大幅度提升消费类电子产品（如电视机顶盒、面包烤箱、移动电话等）的智能化程度。Sun公司为场先机，在1991年成立了一个称为Green的项目小组，帕特里克、詹姆斯·高斯林詹姆斯·高斯詹姆斯·高斯詹姆斯·高斯、麦克·舍林丹和其他几个工程师一起组成的工作小组在加研究开发新技术，专攻计算机在家电产品上的嵌入式应用。

热心网友 时间：2022-05-01 20:04

ava这种语句分为 JavaSE,javaEE,javaME,我们平时说的java一般指的是javaSE.
javaSE是最基础的.
javaEE一般是企业级开发应用.
javaME一般是嵌入式开发,如手机游戏,汽车小软件类的.

热心网友 时间：2022-05-01 23:02

　　说到Java的功能，该语言实际上分为三个(免费)版本：JavaSE(标准版)、JavaEE(企业版)和JavaME(微型版)。SE就是大家学的Java基础，EE是公司最常用的用于网站开发(PC端)，ME用于移动端开发，现在熟悉的安卓系统就是用JavaME开发的。
　　关于JavaEE，首先最重要的一点是，它是在SE之上分层的，这不是一个完全不同的应用程序。在JavaSE中所能做的一切在JavaEE中都是可能的。EE只是让开发人员做更多的事情，它是为那些为企业构建大规模系统的it开发人员而设计的。

热心网友 时间：2022-05-02 02:17

AVAEE是指java enterprise edition，java企业版，多用于企业级开发，包括web开发等等很多组建；

Java和JavaEE区别：

1. Java是一种可以撰写跨平台应用软件的面向对象的程序设计语言。Java 技术具有卓越的通用性、高效性、平台移植性和安全性，广泛应用于PC、数据中心、游戏控制台、科学超级计算机、移动电话和互联网，同时拥有全球最大的开发者专业社群。正式成立于1995年，广泛应用于人们的生活、工作、娱乐等等方面。

2. Java分为三个版本：Java SE(标准版)、Java EE(企业版)、Java ME(微型版)。其中JavaSE就是大家学JavaEE和JavaME的基础，换而言之学Java先从JavaSE开始，JavaSE 包含了支持 Java Web 服务开发的类，JavaEE是企业最常用的用于企业级开发应用的，Java ME主要是移动段的开发应用。

3. 通过以上，Java和JavaEE的区别在哪，就特别的明显了。那么为什么很多培训主打JavaEE培训呢?是因为JavaEE在Java中，比JavaSE和JavaME应用更加广泛，价值更高，所以很多的培训机构就直接主打JavaEE培训，不过其他两个方面的Java知识也是要大致掌握的。

扩展资料

Java EE是 J2EE的一个新的名称，之所以改名，目的还是让大家清楚J2EE只是Java企业应用.随着WEB和EJB容器概念诞生，使得软件应用业开始担心SUN的伙伴们是否还在Java平台上不断推出翻新的标准框架，致使软件应用业的业务核心组件架构无所适从，从一直以来是否需要EJB的讨论声中说明了这种彷徨。

用于IT行业的使用，是属于现在新型的IT行业发展。

热心网友 时间：2022-05-02 05:48

Java和JavaEE区别：

1. Java是一种可以撰写跨平台应用软件的面向对象的程序设计语言。Java 技术具有卓越的通用性、高效性、平台移植性和安全性，广泛应用于PC、数据中心、游戏控制台、科学超级计算机、移动电话和互联网，同时拥有全球最大的开发者专业社群。正式成立于1995年，广泛应用于人们的生活、工作、娱乐等等方面。

2. Java分为三个版本：Java SE(标准版)、Java EE(企业版)、Java ME(微型版)。其中JavaSE就是大家学JavaEE和JavaME的基础，换而言之学Java先从JavaSE开始，JavaSE 包含了支持 Java Web 服务开发的类，JavaEE是企业最常用的用于企业级开发应用的，Java ME主要是移动段的开发应用。

3. 通过以上，Java和JavaEE的区别在哪，就特别的明显了。那么为什么很多培训主打JavaEE培训呢?是因为JavaEE在Java中，比JavaSE和JavaME应用更加广泛，价值更高，所以很多的培训机构就直接主打JavaEE培训，不过其他两个方面的Java知识也是要大致掌握的。

扩展资料

Java EE是 J2EE的一个新的名称，之所以改名，目的还是让大家清楚J2EE只是Java企业应用.随着WEB和EJB容器概念诞生，使得软件应用业开始担心SUN的伙伴们是否还在Java平台上不断推出翻新的标准框架，致使软件应用业的业务核心组件架构无所适从，从一直以来是否需要EJB的讨论声中说明了这种彷徨。

他们两者都是作为巨大的新型IT行业，也是今后一个的就业趋势，而源码时代作为其开发公司，投入了大量的资金，具有创新能力，也抓住了现在的就业趋向。

热心网友 时间：2022-05-02 09:36

我刚学完，需要Java资料的可以+我扣扣：1760/88/23/41 ，无偿分享

热心网友 时间：2022-05-02 13:41

在别的地方有问过这问题了,你到百度一搜就能找到