黑马程序员——Java基础加强—高新技术

                                        黑马程序员——Java基础加强—高新技术
---------------------- <a href="http://www.itheima.com"target="blank">ASP.Net+Unity开发</a>、
<a href="http://www.itheima.com"target="blank">.Net培训</a>、期待与您交流！ ----------------------   


一、Eclipse集成开发环境：
   Eclipse :2011年11月，IBM投资4000万美元贡献给开源社区。Eclipse 是支持多语言的开发平台。它的价值是为可扩展的集成开发环境提


供了一个开放源码平台，这个平台允许任何人构建与环境和其他工具无缝集成的工具（插件）。Eclipse除了一个小型的运行时核心之外，其


余的都是插件。
IDE:Integrated Development Environment，集成开发环境。


 1、在Eclipse 中设置快捷键：
窗口—属性—生成—编辑——键管理
Windows->Preferences->General -> Editors ->Key （Content Assist：内容助理）


2.在Eclipse里面如何调试查看一个变量的值？
(看到甲壳虫图标，就是调试模式)
a.debug as:在Debug透视图进行调试。
b.选中要调试的变量，右击选择Watch。  
常用：


F5：调入调试内部
F6：单步调试下一步不进入函数内部。 
F7：由函数内部返回到调用处。 
F8：直执行到下一个断点。 
（4）Ctrl+Pg~ －－对于XML文件是切换代


3.设置模板 
Windows->Preferences->General -> Editors ->Templates


Syso 会 自动补全System.out.println();
或者 Alt+/ 快捷键


4.Eclipse插件安装方法：
1.拷贝安装。
2.Links安装：eclipse目录下创建links目录>>在links下创建link文件，指定插件路径。path=D:/Plugins-    Download/GEF-All-3.1；一个


link文件里面可以添加多个path。
3.Update安装。只要知道插件的更新地址就行。Help>>software update>>find and install>>选择“search for new features to install


”>>next >>“New Renote Site”,添加新的站点后，按eclipse更新向导就可以完成插件安装了。


插件查看：
帮助—关于Eclipse —软件安装
Help >>About Eclipse SDK>>Plug-in Details
            
二.JDK1.5新特性：
泛型：使用泛型来接收类中操作的引用数据类型 <>
当类中的操作的引用数据类型不确定的时候，可以使用泛型表示.
好处：1.运行时期的问题转换成编译失败，体现在编译时期，方便程序员解决问题，编译不通过，更不可能运行成功。
      2.避免强转的麻烦
      
泛型技术：其实应用在编译时期，是给编译器使用的技术，到了运行时期，泛型就不存在了
泛型的擦除：编辑器检查了泛型的类型正确后，在生成的类文件中是没有泛型的。  
泛型的补偿：因为存储的时候，类型已经确定了是同一个类型的元素，所以在运行时，只要获取到该元素的类型，在内部进行一次转换即可。


泛型定义：
1.定义在类上：泛型类定义的泛型在整个类中都有效，泛型类对象明确操作类型后，所有操作类型都固定啦。
2.定义在方法上：静态方法使用泛型只能定义在方法上
3.泛型定义在接口上
方法上：
 public static <Q> void function(Q t) { 
System.out.println("function:"+t); 
} 
接口上：
package com.itheima.connection;


public class GenericDemo5 {


/**
* @param args
*/
public static void main(String[] args) {
InterImpl i=new InterImpl<>();
i.show(4);
i.show("haha");


}


}
interface Inter<T>{
void show(T t);
}


class InterImpl<T> implements Inter<T>{


@Override
public void show(T t) {
System.out.print("show:"+t);

}

}
泛型的限定：
上限：？extends E：可以接收E类型或者E的子类型对象。 
下限：？super E：可以接收E类型或者E的父类型对象。


可变参数：当一个方法要处理的参数不确定时，则可以设置可变参数
格式：参数类型 ....变量名


 public class TestParameter {  
     public static void main(String[] args) {
         System.out.println(add(1,2,3,4,5));
         System.out.println(add(1,3));
     }




     public static int add(int... number){ 
        int sum = 0 ;
        for (int i = 0 ; i < number.length ; i++) {
            sum += number[i] ;
        }
        return sum ;
    }
 
 }


 有多个参数累加 ，要放到最后 pbulc static int add(int x,int ....arg)
 
2.增强for循环：foreach语句简化了迭代器


格式：for(元素类型、变量名：Connection集合&数组){


}




增强for循环用在迭代器中 参数(声明变量 、迭代内容)


1.Collection 单列集合
ArraList al=new ArryList()
al.add("hao123");
al.add("5858");
for(Object o:al){ 
String s=(String)o
System.out.println(s); 
}
2.使用在Map集合中:
Map集合原则是是不能实现for迭代的，Map没有Iterator 方法。
jdk5中新定义的接口，就一个方法iterator方法，只有实现了Iterable接口的类,才可保证有Iterator方法，
增强for内部还是用迭代器实现的，要将Map转为Set。
Map map = new HashMap();
 map.put(1, "a");  
 map.put(2, "b"); 
 
 Set entrySet=map.entrySet();//获取Entry 键值对象
 Iterator it=entrySet.iterator();
 while(it.hasNext()){
    Map.Entry en=(Entry)it.next();
    Integer key=(Integer)en.getKey();   //分别获取Key 和Value值
    String  value=(String)en.getValue();
    
    System.out.println(key + "=" + value); 
 }
 
 使用 for增强：
 for(Object obj：map.entrySet()){
       Map.Entry entry = (Entry) obj;  // obj 依次表示Entry 迭代的内容        
 }     System.out.println(entry.getKey() + "=" + entry.getValue()); 
 
3.递归：函数自身调用自身，功能内部又用到了该功能，但是传递的参数不确定。
递归的使用：1.一定要定义递归的条件
            2.递归的次数不宜太多，否则会发生栈内存溢出。(栈内存中不断的加载同一个函数)
            
4.枚举：1.某个类型变量取值只能未若干个固定值，否则会报错，枚举可以再编译时就控制非法值收入。
        2.枚举成员只有一个，就可以作为为单例模式实现。


如：定义星期变量只能是周一到周日 1-7


package com.itheima.reflect.demo;


public class EnumTest {


/**
* @param args
*/
public static void main(String[] args) {
WeekDay wd=WeekDay.SUN;
System.out.println(wd);

//打印weekday在WeekDay中的角标
  System.out.println(wd.ordinal());
// 获取指定的值  valueOf() 静态方法
     System.out.println(wd.valueOf("MON"));
//  获取所有的值
System.out.println(wd.values().length);
      
}
//创建一个枚举应用 enum类,定义在内部
   public enum WeekDay{
 SUN,MON,TUE,WED,THI,FRI,SAT
}
}
打印：
SUN
0
MON
7


枚举的构造方法:构造方法私有化private
   public enum WeekDay{
 SUN,MON,TUE,WED,THI,FRI,SAT(6)
 //SUN——FRI初始化调用无参构造方法
 public WeekDay(){
 }
 //SAT(6) 调用的是带参数WeekDay(int day)
  public WeekDay(int day){
 }
}
枚举带抽象方法：(变量取值固定，定义抽象意义不大 )


交通灯管理系统讲到抽象方法


 public enum TrafficLamp{
      //new子类的对象，调用父类的构造方法。
      RED(40){
          public TrafficLamp nextLamp() {
              return GREEN ;
          }
      },
      GREEN(60){
          public TrafficLamp nextLamp() {
              return YELLOW ;
          }
      },
      YELLOW(5){
          public TrafficLamp nextLamp() {
              return RED ;
          }
      };
        //定义抽象方法：
      public abstract TrafficLamp nextLamp() ;
       // 定义交通灯的时间，成员变量
      private int time ; 
      private TrafficLamp(int time) {
          this.time = time ; 
      }
  }


5.基本数据类型自动拆箱装箱：
方便操作基本类型值，将其封装成对象，定义了属性和行为，丰富数据操作


左边到右边是封装，右转左则是拆箱，装箱与拆箱是一个相互的过程。
基本类型         封装类型
byte              Byte
short             Short
int               Integer
float             Float
double            Double
public class TestBox {
    public static void main(String[] args) {


        Integer i = 5 ;
// 自动装箱：将基本数据类型int 5自动封装给一个Integer对象
       Integer i = new Integer(5) ;
      
       Integer i = 5; //自动装箱，1.5版本后的写法；
        
        System.out.println(i + 5);
              
        自动拆箱原理：i.intValue()
       
        i=i.intValue()+5  //5是int类型，i是对象封装类型，相加是将i自动转换为int 型 即自动拆箱        
        
        Integer a = 13 ; 
        Integer b = 13 ; 
        System.out.println(a==b); true a 、b指向的是同一个对象
   
    }
}
举例：Integer x = 1; x = x + 1;  经历了什么过程？装箱——>拆箱——>装箱；


享元模式（flyweight）：如果有很多很小的对象，我们会经常用到，用的时候该对象的内部状态都没有变化，那么就可以把他变成一个对象


。那些不同的属性把它变成方法的参数（外部状态），那些相同的属性叫内部状态。


6.反射：


反射就是将一个Java类中各个成分映射成想要的Java类，通过反射来获取类的方法属性等信息。
反射实现步骤：
            1.得到Class对象，也就是获得字节码对象(每个类都有对应的字节码对象)
            2.实例对象，获得构造函数，属性，方法。
            3.访问属性、方法、调用构造函数创建该类对象。
 获取Class对象三中方式：
   方式一：Class.forName("com.itheima.Person")// 获取指定字符串类名，加载字节码文件
   方式二：Class clazz=Person.class ;//明确类 每个数据类型都有静态的.class属性，格式：类名.class 。
   方式三：clazz=new Person().getClass();// 对象.getClass()方法，必须有该类对象
   
反射获取成员方法：getMethod()方法获取
   Class clazz=Person.class //获取Class对象 
   Method m=clazz.getMethod(要获取的方法名，类型.class);
          m.invoke()//调用其方法
 package com.itheima.reflect.demo;


import java.lang.reflect.Constructor;
import java.lang.reflect.Method;


public class ReflectDemo4 {


/**
*@throws Exception 
* @hutian
*/
//反射获取成员函数，getMethod
public static void main(String[] args) throws Exception {

getMethodDemo3();

getMethodDemo1();
}
    public static void getMethodDemo() throws Exception{
    // 获取Class对象
    Class clazz=Person.class
     
    Method m=clazz.getMethod("paramMethod", String.class,int.class);  //获取方法
   
    //invoke()表示调用的意思，需要传入对象和参数
    m.invoke("小强", 18);
    }
    
    //获取指定Class类中的所有公共函数。。
    public static void getMethodDemo1() throws Exception{
    // 类名，字符串获取反射信息
    Class clazz=Class.forName("com.itheima.bean.Person");
     
    Method[] methods=clazz.getMethods();  //getMethods()获取的是共有的方法
            methods=clazz.getDeclaredMethods(); //获取本类中所有方法，包括私有。
        
    for(Method m:methods){
    System.out.println(m);
    }
   
    }
}
 
 反射构造方法：Constructor 构造器，getConstructor()获取 
    Class clazz=Class.forName("com.itheima.bean.Person")
    //获取带参数的构造方法
    Constructor ct= clazz.getConstructor(String.class,int.class);
    //对象初始化，使用构造器的newInstance()
    Object obj=ct.newInstance("张三",30);
     
     
 反射成员变量：Field 类代表某个类中的成员变量
     //1.获取Class对象
     Class clazz=Class.forName("com.itheima.bean.Person")
      Object obj=clazz.newInstance();  //初始化
     //fl 对象存储的是Person类country 属性值和它所属的对象
     Field fl = clazz.getField("country"); //getField()获得的public 共有的成员country（国家）
   
     //暴力反射
     Field fl2 = clazz.getDeclaredField("name"); //获取类成员，包括private私有的成员
           fl2.setAccessible(true);
       
 案例展示
 package com.itheima.reflect.demo;


import java.lang.reflect.Field;


public class ReflectPoint {


/**
* @param args
*/

private int x ;
public int y ;
public String str="bahabak" ;
public String str1="blue" ;  
public String str2="balck" ; 
public static void main(String[] args) throws Exception {
ReflectPoint rp=new ReflectPoint();
System.out.println("改变前的值："+rp);
ChangeValue(rp);
System.out.print("改变后的值："+rp);


}
public ReflectPoint(String str,String str1,String str2){
super();
this.str=str;
this.str1=str1;
this.str2=str2;
}
public ReflectPoint(){
super();
this.x=x;
this.y=y;
}
public int getX() {
return x;
}
public void setX(int x) {
this.x = x;
}
public int getY() {
return y;
}
public void setY(int y) {
this.y = y;
}
public String getstr() {
return str;
}
public void setstr(String str) {
this.str = str;
}
public String getStr1() {
return str1;
}
public void setStr(String str1) {
this.str1 = str1;
}

public String getStr2() {
return str2;
}
public void setStr2(String str2) {
this.str2 = str2;
}

public String toString() {
      return str+ ":" + str1+":"+str2 ; 
 }
 
public static void ChangeValue(Object obj)throws Exception{
// 获取File对象，先获取Class对象，Filed对象得到成员字段信息
Field[] fl = obj.getClass().getFields() ;
for(Field field:fl){
if(field.getType().equals(String.class)){
  if(field.getType()==String.class) {
       
    String old=(String) field.get(obj);
    String newString=old.replace('b', 'a');
    // 保存修改后的数据
       field.set(obj, newString) ;
     
  }
}
}
 
}


}
打印：
改变前的值：bahabak:blue:balck
改变后的值：aahaaak:alue:aalck
       
反射作用：实现框架功能
练习：　写一个小框架，该框架的作用则是根据用户的需求设置不同的集合类型如ArrayList、HashSet等，存入数据。
       通过配置文件config.properties 来完成集合的选择   
 package com.itheima.reflect.demo;


import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.util.Collection;
import java.util.Properties;


public class ReflectTest1 {


/**
* @param args
* @throws Exception 
*/
public static void main(String[] args) throws Exception {
// 文件存入数据 FileInputStream

FileInputStream fis=new FileInputStream("config.properties");

Properties pt = new Properties() ;
        //按照行从读取流中属性键值对元素
        pt.load(fis);
        //关闭流
        fis.close();
        
        String className = pt.getProperty("className") ; 
        //不同的集合类型如ArrayList、HashSet,Collection 跟接口，反射创建实体
        Collection cot=(Collection) Class.forName(className).newInstance();
                   cot.add("a");
                   cot.add("haha");
                   cot.add("helloworld");
                   cot.add("love you?");
                   
                   System.out.println(cot.size());
        
}


}


7.代理与类加载器：
代理类：JVM可以在运行时动态生成类的字节码，这种动态生成的往往被用作代理类。
代理机制：每个代理实例都具有一个关联的调用处理程序。对代理实例调用方法时，
         将对方法调用进行编码并将其指派到它的调用处理程序的 invoke 方法。
举例：各人觉得网上购物，通过某宝购物平台，这个购物平台就像是代理。


代理体现：采用工厂模式和配置文件的方式进行管理，实现日志功能
JVM生成的动态类必须实现一个或多个接口，所以，JVM的动态类只能用作具有相同接口的目标类的代理。
实现AOP功能的封装与配置：
Public class BeanFactory{
Properties props=new Properties();
Public BeanFactory(InputStream ips){
Props.load(ips);
}
}public Object getBean(String name){
String className==props.getProperty(name);//根据名字拿类名
Class clazzName=Class.forName(className);
Object bean=clazz.newInstance();
If(bean instanceof ProxyFactoryBean){
Object proxy=null;
ProxyFactoryBean proxyFactoryBean=( ProxyFactoryBean)bean;
Advice advice=(Advice)Class.forName(props.getProperty(name+”.advice”)).newInstance();//系统功能对象
Object target=class.forName(props.getProperty(name+”.advice”)).newInstance();
//目标对象
proxyFactoryBean.setAdvice(advice);
proxyFactory.setTarget(target);
Object proxy=ProxyFactoryBean(bean).getProxy();
}return null;
}




8.类加载器：
      顾名思义类加载的工具，将类加载到Java虚拟机中。JVM运行将类的字节码文件加载进来。由加载器名称定位和产生类的字节码依据返


回给JVM。


1.过程：
Java 源程序（.java 文件）在经过 Java 编译器编译之后就被转换成 Java 字节代码（.class 文件）。类加载器负责读取 Java 字节代码，


并转换成 java.lang.Class类的一个实例。


2.类加载器分类：一般由系统提供，另一类由开发人员自己定义类加载器


引导加载器(Bootstrap) ：它用来加载 Java 的核心库，是用原生代码来实现的，并不继承自java.lang.ClassLoader。
扩展加载器(ExtClassLoader 的实例)：加载Java扩展库
系统加载器(AppClassLoader的实例)：根据Java类ClassPath路径来加载Java类。
自定义加载器：系统已经定义了一些类加载器，为了达到特殊功能，开发者自己定义一些类加载器
自定义的类加载器要继承ClassLoader。


3.类加载器的委托机制: 每个类加载器加载类时，先委托给其上级父类加载器，如果没有，直到BootStrap(祖宗类）加载器，当顶级父类加载


器没有加载到类时，再尝试自己加载，还加载不到就抛ClassNotFoundException，不会再去找下一级了。


基本上所有的类加载器都是有一个父类加载器，都是java.lang.ClassLoader 类的一个实例


4.相关方法：
getClassLoader() 返回该类的类加载器。返回类型 ClassLoader  
getParent()  返回该类加载器的父类加载器。 
loadClass(String name)  加载名称为 name的类，返回的结果是 java.lang.Class类的实例。 
findClass(String name)  查找名称为 name的类，返回的结果是 java.lang.Class类的实例。 
findLoadedClass(String name)  查找名称为 name的已经被加载过的类，返回的结果是 java.lang.Class类的实例。 
defineClass(String name, byte[] b, int off, int len)  把字节数组 b中的内容转换成 Java 类，返回的结果是 java.lang.Class类的实


例。这个方法被声明为 final的。
resolveClass(Class<?> c)  链接指定的 Java 类。


package com.itheima.proxy;


public class ProxyDemo {


/**
* @param args
*/
public static void main(String[] args) {
   ClassLoader loader = ProxyDemo.class.getClassLoader();  //通过  getClassLoader() 方法就可以获取到定义此类加载器


的引用
   while (loader != null) {              
    System.out.println(loader.toString());             
    loader = loader.getParent();   //通过递归调用 getParent() 方法来输出全部的父类加载器       
   
   } 


}


}
 打印结果：
sun.misc.Launcher$AppClassLoader@fb56b1
sun.misc.Launcher$ExtClassLoader@f8968f






 ---------------------- <a href="http://www.itheima.com"target="blank">ASP.Net+Unity开发</a>、
<a href="http://www.itheima.com"target="blank">.Net培训</a>、期待与您交流！ ----------------------