java基础学习（9

第六章  内部类与异常类

6.1内部类

java支持在一个类中声明另一个类，这样的类称为内部类，而包含内部类的类称为内部类的外嵌类。

内部类与外嵌类的重要关系如下：

（1）外嵌类中的变量在内部类中仍然有效，内部类也可以调用外部类中的方法。

（2）内部类中不能声明类变量和类方法，外嵌类的类体中可以用内部类变量声明对象作为外嵌类的成员。

/*
 内部类的访问规则：
 1.内部类可以直接访问外部类中的成员，包括私有
 之所以可以访问外部类的成员，是因为内部类中持有了一个外部类的引用。格式：外部类名.this
 2，外部类要访问内部类，必须建立内部类对象；
 
 访问格式：
 当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中。可以直接建立内部类对象。
 格式：外部类名.内部类名        变量名=外部类对象.内部类对象
 Outer.Inner in=new Outer().new Inner();
 3，当内部类在成员位置上，就可以被成员修饰符所修饰。
 比如：private：将内部类在外部类中进行封装。
 static:内部类就具备了static 的特性
 当内部类被静态修饰后，只能访问外部中的static成员，出现了访问局限。
 在外部其他类中，如何访问static内部类的非静态成员呢？？？
 new Outer.Inner().function();
  在外部其他类中，如何访问static内部类的静态成员呢？？？
 Outer.Inner.function(); 
 注意：当内部类中定义了静态成员，该内部类必须是static的。
 */
class Outer   //外部类
{
	//private int x=3;
	private static int x=3;
	static class Inner{ //内部类
		//int x=4;
		static void function(){
			System.out.println("inner:"+x);
		}
	}
	void method(){
		Inner in=new Inner();
		in.function();
	}

}
class InnerClassDemo{     //外部类的其他类
	public static void main(String[] args)
	{
		Outer.Inner.function();
		//new Outer.Inner().function();
		//Outer out=new Outer();
		//out.method();
		//直接访问内部类中的成员
		
	}
}

6.2   匿名类

java允许用户使用一个类子类的类体创建一个对象，也就是说，在创建子类对象时，除了使用父类的构造方法外还有类体，该类体被看做子类去掉类声明的类体，称为匿名类。

匿名类就是一个子类，由于无名可用，所以不可能用匿名类声明对象，但却可以直接用匿名类创建一个对象。

假设People是一个类，那么下面代码就是用People的一个子类（匿名类）创建对象：

new  People{

匿名类的类体

}

因此，匿名类可以继承父类的方法，也可以重写父类的方法。匿名类一定是内部类，匿名类可以调用外嵌类的变量和方法 ，匿名类的类体中不能声明static成员变量和static方法。

6.2.2   和接口有关的匿名类

假设computable是一个接口，那么，java允许直接用接口名和一个类体创建一个匿名对象，此类题被认为是实现了comoutable接口的类去掉类声明后的类体，称为你们匿名类。

new computable(){

实现接口的匿名类的类体

}

文件的读写操作：

package readWriteFile;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.UnsupportedEncodingException;

public class ReadFile {
	public static void main(String[] args) {

		//文件读
		File file=new File("text.txt");
		if(file.exists()){
			System.out.println("exist");
		try {
			FileInputStream fis=new FileInputStream(file);
			InputStreamReader intraad=new InputStreamReader(fis,"GBK");
			BufferedReader  bread=new BufferedReader(intraad);
			
			String line;
			while((line=bread.readLine())!=null){
				System.out.println(line);
			}
			bread.close();
			fis.close();
			intraad.close();
			
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (UnsupportedEncodingException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		}
		try {

			//文件写
			File newfile=new File("newtext.txt");
			FileOutputStream fos=new FileOutputStream(newfile);
			OutputStreamWriter  out=new OutputStreamWriter(fos,"GBK");
			BufferedWriter bw=new BufferedWriter(out);
			
			bw.write("长歌行\n");
			bw.write("长歌行\n");
			bw.write("长歌行\n");
			bw.write("长歌行\n");
			bw.write("长歌行\n");
			
			bw.close();
			out.close();
			fos.close();
			System.out.println("文件写入完成！");
			
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (UnsupportedEncodingException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

日期的转化：

package dateDemo;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;

public class Demo02 {
	@SuppressWarnings("unused")
	public static void main(String[] args) throws ParseException {
		Date dl=new Date(System.currentTimeMillis());
		Calendar cl=Calendar.getInstance();
		
		//格式化
		SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
		System.out.println("格式化前："+dl.toString());
		System.out.println("格式化后:"+sdf.format(dl));
	
		//由String转化为Date
		String date="2017-02-24";
		SimpleDateFormat sdf1=new SimpleDateFormat("yyyy-mm-dd");
		Date d2=sdf1.parse(date);
		System.out.println(d2.toString());
		
		//由Date转化为String
		String s1=sdf1.format(d2);
		System.out.println(s1.toString());
	}
}

Myeclipse快捷键：

JSP的内置对象：

request的一些用法：

response实现网页跳转。

session的一些基本方法：

tomcat的优化经验：

去掉对web.xml的监视，把jsp提前写成selvlet.有富余的内存的情况下。加大tomcat的JVM的内存。

Http请求的Get与post方式的区别

1、GET请求，请求的数据会附加在URL之后，以?分割URL和传输数据，多个参数用&连接。URL的编码格式采用的是ASCII编码，而不是uniclde，即是说所有的非ASCII字符都要编码之后再传输。

POST请求：POST请求会把请求的数据放置在HTTP请求包的包体中。上面的item=bandsaw就是实际的传输数据。

因此，GET请求的数据会暴露在地址栏中，而POST请求则不会。

2、传输数据的大小

在HTTP规范中，没有对URL的长度和传输的数据大小进行限制。但是在实际开发过程中，对于GET，特定的浏览器和服务器对URL的长度有限制。因此，在使用GET请求时，传输数据会受到URL长度的限制。

对于POST，由于不是URL传值，理论上是不会受限制的，但是实际上各个服务器会规定对POST提交数据大小进行限制，Apache、IIS都有各自的配置。

3、安全性

POST的安全性比GET的高。这里的安全是指真正的安全，而不同于上面GET提到的安全方法中的安全，上面提到的安全仅仅是不修改服务器的数据。比如，在进行登录操作，通过GET请求，用户名和密码都会暴露再URL上，因为登录页面有可能被浏览器缓存以及其他人查看浏览器的历史记录的原因，此时的用户名和密码就很容易被他人拿到了。除此之外，GET请求提交的数据还可能会造成Cross-site request frogery攻击

4、HTTP中的GET，POST，SOAP协议都是在HTTP上运行的

解释一下什么是servlet？

servlet有良好的生存期的定义，包括加载和实例化，初始化，处理请求以及服务结束。

这个生存期由javax.servlet.Servlet接口的init.servlice和destory方法表达。

说一说servlet的生命周期：

servlet被服务器实例化后，容器运行其init方法，请求达到时运行其service方法，service方法自动派遣运行与请求对应的doXX方法，当服务器决定将实例销毁时调用destroy（）方法。

web容器加载servlet，生命周期开始，通过调用servlet的init()方法进行servlet的初始化。通过调用service（）方法实现，根据请求的不同调用不同的doXX方法。借宿任务，web容器调用servlet的destroy()方法。

servlet的基本结构：

package com.jikexueyuan.entity;

import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class servletdemo extends HttpServlet {

	public void doGet(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {

		response.setContentType("text/html");
		PrintWriter out = response.getWriter();
		out
				.println("<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\">");
		out.println("<HTML>");
		out.println("  <HEAD><TITLE>A Servlet</TITLE></HEAD>");
		out.println("  <BODY>");
		out.print("    This is ");
		out.print(this.getClass());
		out.println(", using the GET method");
		out.println("  </BODY>");
		out.println("</HTML>");
		out.flush();
		out.close();
	}
	public void doPost(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {

		response.setContentType("text/html");
		PrintWriter out = response.getWriter();
		out
				.println("<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\">");
		out.println("<HTML>");
		out.println("  <HEAD><TITLE>A Servlet</TITLE></HEAD>");
		out.println("  <BODY>");
		out.print("    This is ");
		out.print(this.getClass());
		out.println(", using the POST method");
		out.println("  </BODY>");
		out.println("</HTML>");
		out.flush();
		out.close();
	}

	public void init() throws ServletException {
	}

}

servlet  API中forward（）与redirect（）的区别：

答:forward（）仅是容器中控制权的转向，在客户端浏览器地址栏中不会显示出转向后的地址，redirect（）则完全是跳转，浏览器将会得到跳转的地址，并从新发送请求链接。这样，在浏览器的地址栏中就能够看到跳转后的链接地址。因此，forward（）会更加高效，但是在需要跳转到一个其他服务器上的资源，则必须使用sendRedirct()方法。

在JSP页面中，form标签里的method属性为get时调用doGet（），为post时调用doPost().

jsp是servlet的扩展，本质上是servlet的简易形式，更强调应用的外表表达。servlet的应用逻辑是在java文件中，并且完全从html里分离出来。而jsp的情况是java和servlet可以组合成一个扩展名为.jsp的文件。jsp侧重于视图，而servlet则侧重于控制逻辑。

MVC的实现：

M(model一般通过javaBean,EJB实现)-------V(view由jsp页面产生)--------------C(controller一般由servlet产生)

根据部门号从高到低，工资从低到高列出每个员工的信息:

select  *  from employee order by department  desc,salary;