【Java】java进阶知识

1.子类继承后调用的是父类的方法，而不是将代码隐式添加到子类

public class parent {
	private int a=10;//私有变量可通过公有方法访问
	public int getA() {
		return a;
	}
    public static void main(String[] args) {
        son son=new son();
       System.out.print(son.getA());//put 10
    }
}
class son extends parent{
	private int a=9;
	public void name() {
		super.getA();
this.getA();
	}
}

参考:http://blog.youkuaiyun.com/jxqiaole/article/details/45372507

何为子类后访问权限，即访问父类的方法，变量的权限

public class parent {

	public int a=10;//共有变量，子类可直接访问
	public int getA() {
		return a;
	}
    public static void main(String[] args) {
        new parent();
        son son=new son();
        son.name();
    }
}
class son extends parent{
//加上这一句 private int a=0;将输出两个10;
	public son(){
		a=9;
	}
	public void name() {
		 System.out.print(super.getA());//put 9
		 System.out.print(this.getA());//put 9
		
	}
}

总结:

• 1.子类未重写父类成员变量，同时子类有修改变量值:调用的父类方法输出的是子类修改后的值(因为变量作用范围)
• 2.子类重写父类成员变量,不论子类是否修改变量值:调用的父类方法输出的是父类中的值

3.内容是空的是isEmpty(),对象是空的（未实现）为null

4.equals是判断内容相等，”==”是判断内存相等

拓展:equals是根据hashcode比较

5.基本类型是传值，数组，对象等等是传引用(内存地址)

拓展:数组的传参为常见问题，传参后数组为同一个数组，修改将会互相影响到

6.成员变量为什么要用private定义，然后用get,set访问

避免多个类继承基类后，改变成员变量类型编译不通过

7.内部类实例化方法

• 内部类声明为static:

 Outter.Inner aInner=new Outter.Inner();//这种方法的实现没有使用到外部类的构造函数

• 普通内部类:

    	Outter out=new Outter();
    	Outter.Inner innter=Outter.new Inner();

Ps:可以将内部类想象成一个成员变量，普通的变量需要对象出现才能使用，static的可以直接使用

8.形参和实参的区别

比如你定义一个函数void add（int a, int b），这里的a和b就是形参。 当你进行函数调用的时候，add（1, 2），这里的1和2就是实参。 形参就是函数定义时候用的，实参是在函数调用时候用的

9.finally唯一不执行的情况

在catch中添加System.exit(1)

try{
return true; //不会停止finally,finally块会在这个return语句前执行
}catch (SQLException e) {
e.printStackTrace();
}finally{
closeResource();
}

10.Java是一种强类型语言

它能区别多种数据类型，并且通常不允许用一种类型替换另一种。这样，使得编译器能高效处理数据，防止由于类型不匹配导致的运行时错误。所以，效率越高的语言，花费代码越多，给编译器描述的越清晰

11.Java 编程下通过反射获取一个类中的方法名和对应参数类型

实际编程中如果我们要使用系统中未暴露的方法，我们可以通过反射来使用这些方法，但在使用过程中我们很难确定方法对用的参数类型，以下的代码可以帮你得到这些信息：

package cn.sunzn.reflectcase;

import java.lang.reflect.Method;

public class GetMethod {
   public static void main(String[] args) {
       getMethodInfo("java.util.HashSet");
   }

   /**
    * 传入全类名获得对应类中所有方法名和参数名
    */
   @SuppressWarnings("rawtypes")
   private static void getMethodInfo(String pkgName) {
       try {
           Class clazz = Class.forName(pkgName);
           Method[] methods = clazz.getMethods();
           for (Method method : methods) {
               String methodName = method.getName();
               System.out.println("方法名称:" + methodName);
               Class<?>[] parameterTypes = method.getParameterTypes();
               for (Class<?> clas : parameterTypes) {
                   String parameterName = clas.getName();
                   System.out.println("参数名称:" + parameterName);
               }
               System.out.println("*****************************");
           }
       } catch (ClassNotFoundException e) {
           e.printStackTrace();
       }
   }
}

12.java编译与运行

（http://www.360doc.com/content/14/0218/23/9440338_353675002.shtml）

1. 第一步(编译):
   创建完源文件之后，程序会先被编译为.class文件。Java编译一个类时，如果这个类所依赖的类还没有被编译，编译器就会先编译这个被依赖的类，然后引用，否则直接引用，这个有点象make。如果java编译器在指定目录下找不到该类所其依赖的类的.class文件或者.java源文件的话，编译器话报“cant
   find symbol”的错误。
   编译后的字节码文件格式主要分为两部分：常量池和方法字节码。常量池记录的是代码出现过的 所有token(类名，成
   员变量名等等)以及符号引用（方法引用，成员变量引用等等）；方法字节 码放的是类中各个方法的字节码

2. 第二步（运行）：java类运行的过程大概可分为两个过程：

   3. 类的加载
   4. 类的执行。需要说明的是：JVM主要在程序第一次主动使用类的时候，才会去加载该类。也就是说，JVM并不是在一开始就把一个程序就所有的类都加载到内存中，而是到不得不用的时候才把它加载进来，而且只加载一次
      。

13.数据库连接池

● 功能:减少创建连接，再关闭连接的资源消耗
● 初始化:创建一定数量的数据连接放入连接池(数量由最小数量和最大数量影响),在连接空闲时被重复使用
● 增加:连接不够使用时，将创建新连接，直至最大数量。空闲时间最长的连接将被提供给应用程序
● 关闭:连接只有在超过最长空闲时间才会关闭。

//JNDI 通过配置文件Context找到对应字段对应的值
	//感觉就像一个全局静态的单例对象
	Context ctx=new InitialContext();
	DataSource ds=(DataSource)ctx.lookup("java:comp/env/jdbc/hrs");
	Connection conn=ds.getConnection();

14.jsp与servlet不同的编译时期

jsp和servlet的编译时期不一样。使用myeclipse等工具创建的servlet在部署在tomcat时就已经被编译成.class文件了，而jsp被部署到tomcat时还没有被编译。当tomcat启动，第一次访问jsp页面时，jsp才会被编译成servlet，进而被编译成.class文件

15.javabean

javabean起初包含数据实体Bean和封装业务逻辑的实体操作Bean两部分，后业务逻辑java类不需要完全符合javaBean规则，故不将业务逻辑称为javaBean

16.PrepareStatement接口

• 解决sql注入不安全问题

（http://www.360doc.com/content/14/0307/11/16021371_358456176.shtml）

预处理语句将被预先编译好，这条预编译的sql查询语句能在将来的查询中重用，这样一来，它比Statement对象生成的查询速度更快，如果还是用
PreparedStatement
做同样的查询，哪怕参数值不一样，数据库系统还是会去调用之前编译器编译好的执行语句（系统库系统初次会对查询语句做最大的性能优化）

• 明确执行sql类型会提高效率 execute方法执行未知的sql语句类型

executeUpdate执行 INSERT、UPDATE 或 DELETE 语句
executeQuery执行select语句

17.jvm内存问题

(http://blog.youkuaiyun.com/lixingtao0520/article/details/77978333)

change("hello","world")
public static void change(String s1, String s2) {  
1.          String s= "world";  
2.          String ss= "worldworld";  
3.          s1 = s2;  
4.          System.out.println(s==s1);//输出true  
5.          s2 = s1+s2;  
6.          System.out.println(ss==s2);//输出false  
7.          System.out.println("change(s1,s2)---"+s1+"---"+s2);//2:change(s1,s2)---world---worldworld  
8.     }  

结论:s1所指向的是常量池中的"world"，s2=s1+s2代码执行后，会在堆内存中重新创建对象,并将s2指向此堆内存地址