十年蹉跎君莫笑
十年蹉跎君莫笑

java基础增强

1. 静态导入和自动装箱拆箱

(1).静态导入： 导入java里面类的静态成员 import static 包名 类名 静态属性/静态方法/*
(2).自动装箱拆箱：
自动装箱：把基本数据类型赋值给对应的包装类（对象）
自动拆箱：把包装类的对象赋值给对应的基本数据类型

package com.study.lgs;
import static java.lang.System.out;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class ZhuangXiangChaiXiang {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //1、静态导入
        //out.println("aaa");
        
        //2.自动装箱拆箱：
        Integer i=1;//自动装箱  jdk1.5+才能这样写 否则这样写：Integer i=new Integer(1)
        int j=i;//自动拆箱
        
        //3.自动装箱拆箱的典型应用
        List l=new ArrayList();
        l.add(1);//装箱 把对象1装到list对象l里面去
        l.add(2);
        l.add(3);
    
        //迭代器遍历输出
        Iterator k=l.iterator();
        while(k.hasNext()){
            int j1=(Integer)k.next();
            out.println(j1);
            
            
        }
        /*ArrayList al=new ArrayList();
        al.add(1);
        al.add(2);
        al.add(3);
        for(Integer k:al){
            out.println(k);
        }*/
    }

}

2. 增强for循环

    用途：遍历数组或者遍历实现Iterable泛型接口的集合

package cn.study.lgs;
import static java.lang.System.out;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

import org.junit.Test;

public class StrongFor {
    
    @Test
    public void test1(){
        //1、遍历数组
        int i[]={1,2,3};
        for(int k:i){
            out.println(k);
        }
    }
    @Test
    public void test2(){
        //2、遍历集合
        List l=new ArrayList();
        l.add(1);
        l.add(2);
        l.add(3);
    //    l.add("aaa");
        
        for(Object o:l){
//            out.println(o); //不用包装直接以对象的形式输出 也可以
            int i=(Integer) o;
            out.println(i);
        }
        }
    @Test
    public void testMap(){
        Map m=new HashMap();
        m.put("1", "aaa");
        m.put("2", "bbb");
        m.put("3", "ccc");
        //1、传统方案取出Map里面的值 1
        Set s=m.keySet();//通过keyset方法把map里面的每个key存到s里面去
        Iterator i=s.iterator();//迭代遍历s里面的key值
        while(i.hasNext()){
//            String key=(String) i.next();
//            String value=(String) m.get(key);
//            out.println(key+"对应的值为："+value);
            String st=(String) i.next();
            System.out.println(st+ "对应的值为"+m.get(st));
            
//            System.out.println(i.next());  //有错 两次的i.next()不一样
//            System.out.println(m.get(i.next()));
        
            
        }
        
        
    }
    @Test
    public void testMap2(){
        Map m=new HashMap();
        m.put("1", "aaa");
        m.put("2", "bbb");
        m.put("3", "ccc");
        //1、传统方案取出Map里面的值 2
        Set s=m.entrySet();//通过entrySet方法把每组键值存到s中
        Iterator i=s.iterator();//迭代遍历输出s中的值
        while(i.hasNext()){
            Map.Entry me=(Entry) i.next();
            System.out.println(me.getKey()+"对应的值为"+me.getValue());
        }
        
        
        
    }

    @Test
    public void testMap3(){
        Map m=new HashMap();
        m.put("1", "aaa");
        m.put("2", "bbb");
        m.put("3", "ccc");
        //1、增强for循环 1 (keySet实现Iterable泛型接口)
        for(Object o:m.keySet()){
//            String s=(String) o;
//            String value=(String) m.get(o);
//            System.out.println(o+" "+value);
            out.println(o+" "+m.get(o));
        }
        
        
    }
    @Test
    public void testMap4(){
        Map m=new HashMap();
        m.put("1", "aaa");
        m.put("2", "bbb");
        m.put("3", "ccc");
        //1、增强for循环 2 (entrySet实现Iterable泛型接口)
        for(Object o:m.entrySet()){
         Map.Entry me=(Entry) o;
         System.out.println(me.getKey()+" "+me.getValue());
        }
        
        
    }
    
    @Test //增强for循环应该注意的问题 增强for循环只能取数组或者集合里面的数据 不能更改数据；要改数据的话只能用传统方法
    public void test3(){
//        int []i=new int[]{1,2,3};
//        for(int j:i){
//            j=10;//j仅仅是指向取出来的值而已 并不能改变数组里面的值
//            
//        }
//        //传统方法改变数组的值
//        for(int j=0;j

3. 可变参数

使用可变参数的精髓：就是看需要什么类型的数据，需要对象就传入对象/对象数组，需要基本数据类型就传基本数据类型/基本数组

package com.study.lgs;
import java.util.Arrays;
import java.util.List;

import org.junit.Test;

public class KeBianCanShu {
    
    @Test
    public void testSum(){
        int []i={1,2,3};
        sum(i);//可变参数里面可以看成一个数组，所以可以向里面传入数组i
        sum(1,2,3);
    }
    //可变参数按数组方式进行处理，只能放在参数列表的最后，一个参数列表中只能有一个可变参数
    
    public void sum(int...nums){
        int sum=0;
        for(int k:nums){
            sum+=k;
        }
        System.out.println(sum);
    }
    @Test
    public void testArrays(){
        List l=Arrays.asList("1","2","3");//传入普通字符串对象
        System.out.println(l);
        
        String [] s={"1","2","3","4"};//传入字符数组对象
        l=Arrays.asList(s);
        System.out.println(l);
        
        //int []i={1,2,3,4,5};
        Integer []i={1,2,3,4,5};
        l=Arrays.asList(i);//传入基本数据类型整型数组对象 List的l会吧i数组看作一个对象，所以输出的l为一个地址，必须使用包装类的对象以对象方式传入才可输出实际的值
        System.out.println(l);
    }

}
package enumeration;

import org.junit.Test;

//枚举的作用：限定某些程序运行时所需要数据的取值范围
enum Grade{
    A,B,C,D
}
public class DefineEnum {
    @Test
    public void test(){
        DefineEnum.printGrade(Grade.A);
    }
    public static void printGrade(Grade a){
        switch(a){
        case A:
            System.out.println("90");
             break;
        case B:
            System.out.println("80");
            break;
        case C:
            System.out.println("70");
            break;
        case D:
            System.out.println("60");
            break;
        default:
            System.out.println("传入参数有错");
            
        }
    }
}

4.2 定义枚举的字段、构造函数、方法去封装更多的信息

package enumeration;

import org.junit.Test;

//枚举的作用：限定某些程序运行时所需要数据的取值范围
//怎样定义枚举的字段、构造函数、方法去封装更多的信息
enum Grade{
    A("100-90"),B("89-80"),C("79-70"),D("69-60");//对枚举进行实例化
    private String value;//定义每个枚举类型里面存的值
    private Grade(String value){
        this.value=value;
    }
    public String getValue(){ //外部对象获取每个枚举类型里面存的值
        return this.value;
    }
}
public class DefineEnum {
    @Test
    public void test(){
        printGrade(Grade.B);
    }
    public void printGrade(Grade a){
        System.out.println(a.getValue());
    }
}

4.3 带抽象方法的枚举 实例化时必须实现抽象方法

package enumeration;

import org.junit.Test;

//枚举的作用：限定某些程序运行时所需要数据的取值范围
//带抽象方法的枚举 实例化时必须实现抽象方法
enum Grade{
    A("100-90") {
        @Override
        public String getLocalValue() {
            // TODO Auto-generated method stub
            return "优";
        }
    },
    B("89-80") {
        @Override
        public String getLocalValue() {
            // TODO Auto-generated method stub
            return "良";
        }
    },
    C("79-70") {
        @Override
        public String getLocalValue() {
            // TODO Auto-generated method stub
            return "中";
        }
    },
    D("69-60") {
        @Override
        public String getLocalValue() {
            // TODO Auto-generated method stub
            return "差";
        }
    };//对枚举进行实例化 必须实现抽象方法
    
    private String value;//定义每个枚举类型里面存的值
    private Grade(String value){
        this.value=value;
    }
    public String getValue(){ //外部对象获取每个枚举类型里面存的值
        return this.value;
    }
    //带抽象方法的枚举
    public abstract String getLocalValue();
}
public class DefineEnum {
    @Test
    public void test(){
        printGrade(Grade.B);
    }
    public void printGrade(Grade a){
        System.out.println(a.getValue());
        System.out.println(a.getLocalValue());
        
    }
}

4.4 普通单例设计模式与枚举单例设计模式

package enumeration;

//定义普通单态设计模式
class Single{
    private static Single sin=null;
    private Single(){}
    private Single(Single sin){
        this.sin=sin;
    }
    public static Single createShiLi(){
        if(sin==null){
            sin=new Single();
        }
        return sin;
        
    }
}
//定义枚举类型单态设计模式 当枚举里面只有一个对象时也属于单态设计模式
enum EnumSingle{
    A;//枚举中声明的每一个枚举值表示枚举类的一个实例化对象
      //m枚举类的构造函数必须是私有的，因为枚举就是用来限制实例化的对象的，如果构造函数为公有的就可以实例化新的对象，不符合枚举规范    
}
public class DefineSingle {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //普通设计模式的实例化
        Single s1=Single.createShiLi();
        Single s2=Single.createShiLi();
        Single s3=Single.createShiLi();
        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s3);
        
        

    }

}

 4.6 测试枚举中的常用方法

package enumeration;

import org.junit.Test;

//枚举的作用：限定某些程序运行时所需要数据的取值范围
//带抽象方法的枚举 实例化时必须实现抽象方法
//枚举中声明的每一个枚举值表示枚举类的一个实例化对象
//m枚举类的构造函数必须是私有的，因为枚举就是用来限制实例化的对象的，如果构造函数为公有的就可以实例化新的对象，不符合枚举规范    

enum Grade {
    A("100-90") {
        @Override
        public String getLocalValue() {
            // TODO Auto-generated method stub
            return "优";
        }
    },
    B("89-80") {
        @Override
        public String getLocalValue() {
            // TODO Auto-generated method stub
            return "良";
        }
    },
    C("79-70") {
        @Override
        public String getLocalValue() {
            // TODO Auto-generated method stub
            return "中";
        }
    },
    D("69-60") {
        @Override
        public String getLocalValue() {
            // TODO Auto-generated method stub
            return "差";
        }
    };// 对枚举进行实例化 必须实现抽象方法

    private String value;// 定义每个枚举类型里面存的值

    private Grade(String value) {
        this.value = value;
    }

    public String getValue() { // 外部对象获取每个枚举类型里面存的值
        return this.value;
    }

    // 带抽象方法的枚举
    public abstract String getLocalValue();
}

public class DefineEnum {
    @Test
    public void test() {
        printGrade(Grade.B);
    }

    public void printGrade(Grade a) {
        System.out.println(a.getValue());
        System.out.println(a.getLocalValue());

    }

    // 测试枚举的常用方法
    @Test
    public void test2() {
        System.out.println(Grade.A.name());// name()方法返回枚举的名字
        System.out.println(Grade.A.ordinal());// ordinal()方法返回枚举对象在枚举类中的序号
        String str = "B";
        Grade g = Grade.valueOf(Grade.class, str);// valueOf()方法将某个枚举对象对应的字符串转变为枚举对象
                                                    // 实际开发中用于检测用户提交的字符串是否属于自己定义的枚举类型
                                                    // Grade
                                                    // g=Grade.valueOf(str);
        System.out.println(g);
        // for(Grade g:Grade.values()){ //values()方法获取枚举中的每个值
        // System.out.println(g);
        // }

    }
}

4.7 定义一个星期的枚举设置方法返回对应中文星期

package enumeration;

import org.junit.Test;

//定义一个星期的枚举WeekDay
//枚举值：Monday,Tuesday,Wednesday,Thursday,Friday,Saturday,Sunday
//该枚举有一个方法，调用该方法返回中文格式的日期
enum WeekDay{
    Monday {
        @Override
        public String getChineseDay() {
            // TODO Auto-generated method stub
            return "星期一";
        }
    },
    Tuesday {
        @Override
        public String getChineseDay() {
            // TODO Auto-generated method stub
            return "星期二";
        }
    },
    Wednesday {
        @Override
        public String getChineseDay() {
            // TODO Auto-generated method stub
            return "星期三";
        }
    },
    Thursday {
        @Override
        public String getChineseDay() {
            // TODO Auto-generated method stub
            return "星期四";
        }
    },
    Friday {
        @Override
        public String getChineseDay() {
            // TODO Auto-generated method stub
            return "星期五";
        }
    },
    Saturday {
        @Override
        public String getChineseDay() {
            // TODO Auto-generated method stub
            return "星期六";
        }
    },
    Sunday {
        @Override
        public String getChineseDay() {
            // TODO Auto-generated method stub
            return "星期天";
        }
    };
    public abstract String getChineseDay();
    
}
public class HomeWork {
    
    @Test
    public void test(){
        printDay(WeekDay.Friday);
    }
    public void printDay(WeekDay wd){
        System.out.println(wd.getChineseDay());
    }

}

5. 反射

5.1 反射的概念

反射：加载类(获取类的字节码)，获取类里面的各种组成成分
反射的用途：写框架
通过反射获取类里面的各种组成干什么？
                (1) 获取构造函数去实例化对象
                (2) 获取字段去封装数据
                (3) 获取方法去运行

加载类的三种方式：

package refelect;

public class LoadClass {

    public static void main(String[] args) throws ClassNotFoundException {
        // TODO Auto-generated method stub
        //加载类的方法
        //1、Class类的forName()方法
        Class c1=Class.forName("refelect.Person"); //把类的字节码加载到内存中去
        System.out.println(c1);
        //2、通过对象的getClass()方法
        Person p=new Person();
        Class c2=p.getClass(); //把类的字节码加载到内存中去
        System.out.println(c2);
        //3、通过.class
        Class c3=Person.class; //把类的字节码加载到内存中去
        System.out.println(c3);

    }

}

5.2  通过反射获取类的构造函数 

package refelect;

import java.io.InputStream;
import java.util.List;

public class Person {

    public String name = "aaa";

    private int password = 123;

    private static int age = 23;

    public static int score = 90;

    public Person() {
        System.out.println("person");
    }

    public Person(String name) {
        System.out.println("person name");
    }

    public Person(String name, int password) {
        System.out.println("person name password");
    }

    private Person(List list) {
        System.out.println("list");
    }

    public void aa() {
        System.out.println("aa");
    }

    public void aa(String name, int password) {
        System.out.println(name + password);
    }

    public Class[] aa(String name, int[] password) {
        return new Class[] { String.class };
    }

    private void aa(InputStream in) {
        System.out.println(in);
    }

    public static void aa(int num) {
        System.out.println(num);
    }

    public static void main(String[] args) {
        System.out.println("main");
    }
}
package refelect;

import java.lang.reflect.Constructor;
import java.util.ArrayList;
import java.util.List;

import org.junit.Test;

public class GetConstructor {
    
    //通过反射获取类里面的无参构造函数 public Person()
    @Test
    public void test1() throws  Exception{
        //1、获取无参构造函数 public Person()
        Class c1=Class.forName("refelect.Person");//加载类到内存中去
        Constructor cs1=c1.getConstructor(null);//通过传入的可变参数获取对应的构造函数，此处获取无参构造函数
        Person p1=(Person) cs1.newInstance(null);//通过无参构造函数实例化对象
        String s=p1.name;
        System.out.println(s);
    }
    //通过反射获取类里面的有一个参数构造函数  public Person(String name)
    @Test
    public void test2() throws  Exception{
        
        Class c1=Class.forName("refelect.Person");//加载类到内存中去
        Constructor cs1=c1.getConstructor(String.class);//记住:必须传入String.class告知参数类型为字符串，不能传入"aaa"之流
        Person p=(Person) cs1.newInstance("aaa");//通过构造函数实例化对象
        System.out.println(p.name);
    }
    //通过反射获取类里面的有两个参数构造函数 public Person(String name,int passord)
    @Test
    public void test3() throws  Exception{
        
        Class c1=Class.forName("refelect.Person");//加载类到内存中去
        Constructor cs1=c1.getConstructor(String.class,int.class);
        Person p=(Person) cs1.newInstance("aaa",123);
        System.out.println(p.name);
    }
    //通过反射获取类里面的私有带参构造函数  private Person(List l)
    @Test
    public void test4() throws  Exception{
        //getConstructor()方法只能获取public类型的构造函数
        //getDeclaredConstructor()方法能够获取所有声明的构造函数包括私有的
        Class c1=Class.forName("refelect.Person");//加载类到内存中去
        Constructor cs1=c1.getDeclaredConstructor(List.class);
        cs1.setAccessible(true);//记住:一定要暴力地将私有的构造函数属性设置为可以被外部访问，否则将会报错
        Person p=(Person) cs1.newInstance(new ArrayList());
        System.out.println(p.name);
    }
    //创建对象的另一种途径 直接通过反射出的类的newInstance()方法 ,自动调用无参构造函数实例化，以下代码等价于test1
    @Test
    public void test5() throws  Exception{
        //getConstructor()方法只能获取public类型的构造函数
        //getDeclaredConstructor()方法能够获取所有声明的构造函数包括私有的
        Class c1=Class.forName("refelect.Person");//加载类到内存中去
        Person p=(Person) c1.newInstance();
        System.out.println(p.name);
    }

}

5.3 通过反射获取类的方法以及main方法的特殊获取

package refelect;

import java.io.FileInputStream;
import java.io.InputStream;
import java.lang.reflect.Method;

import org.junit.Test;

//通过反射获取类里面的方法
public class GetMethods {
    
    //获取方法 public void aa()
    @Test
    public void test1() throws Exception{
    Class c1=Class.forName("refelect.Person");//加载类
    Method m=c1.getMethod("aa", null);//获取类里面的方法 第一个参数指定是哪一个方法，第二个参数指定方法的参数类型
    m.invoke(c1.newInstance(), null);//执行方法，第一个参数指定执行方法需要实例化的对象，第二个参数为需要传入的参数
    }
    
    //获取方法 public void aa(String name,int password)
    @Test
    public void test2() throws Exception{
        Class c1=Class.forName("refelect.Person");//加载类
        Method m=c1.getMethod("aa", String.class,int.class);
        m.invoke(c1.newInstance(), "lgs",21);
    }
    
    //获取方法 public Class[] aa(String name,int[] password)
    @Test
    public void test3() throws Exception{
        Class c1=Class.forName("refelect.Person");//加载类
        Method m=c1.getMethod("aa", String.class,int[].class);
        Class [] cls=(Class[]) m.invoke(c1.newInstance(), "lgs",new int[]{1,2,3});
        System.out.println(cls[0]);
    }
    //获取方法 private void aa(InputStream in)
    @Test
    public void test4() throws Exception{
        Class c1=Class.forName("refelect.Person");//加载类
        Method m=c1.getDeclaredMethod("aa", InputStream.class);//获取私有方法
        m.setAccessible(true);//暴力解除方法私有属性
        m.invoke(c1.newInstance(), new FileInputStream("c:\\1.txt"));
        
    }
    //获取方法 public static void aa(int num)
    @Test
    public void test5() throws Exception{
        Class c1=Class.forName("refelect.Person");//加载类
        Method m=c1.getDeclaredMethod("aa", int.class);//获取私有方法
        
        m.invoke(c1.newInstance(), 23);//静态方法调用时不需要对象，因此第一个参数可以为空
        
    }
    //获取方法 public static void main(String[] args)
    @Test
    public void test6() throws Exception{
        Class c1=Class.forName("refelect.Person");//加载类
        Method m=c1.getDeclaredMethod("main", String[].class);//获取私有方法
        
        //m.invoke(null, new String[]{"1","2"});//错误的 因为在传数组参数进去给main函数的时候会被自动拆分为String s1和String s2 main函数里面没有这两种参数所以报错参数个数不正确
        //m.invoke(null, new Object[]{new String[]{"1","2"}});//静态方法调用时不需要对象，因此第一个参数可以为空，此时main函数会被自动拆分为String[]数组，不会报错
        m.invoke(null, (Object)new String[]{"1","2"});//这哥们不是喜欢把数组拆分为字符串吗，就加Object强制转换骗他我不是数组
    }
}

5.4 通过反射获取类的字段

package refelect;

import java.lang.reflect.Field;

import org.junit.Test;

//通过反射获取字段
public class GetFields {
  //获取字段public String name="lgs";
    @Test
  public void test1() throws Exception{
        
      Class c1=Class.forName("refelect.Person");//加载类
      Field f=c1.getField("name");//获取字段 参数为要获取的字段的名称
     // String s= (String) f.get(c1.newInstance());//获取字段的值  参数为对应的对象
      Object o=f.get(c1.newInstance());//获取字段的值  参数为对应的对象
      
      //获取字段的类型
      Class type=f.getType();
      if(type.equals(String.class)){
          String s=(String) o;
          System.out.println(s);
      }
      
      //设置字段的值
      Person p=(Person) c1.newInstance();
      f.set(p, "yc");
      System.out.println(p.name);

      
  }
    //获取字段private int password=123;
    @Test
      public void test2() throws Exception{
            
          Class c1=Class.forName("refelect.Person");//加载类
          Field f= c1.getDeclaredField("password");
          f.setAccessible(true);//暴力修改字段的可视性为公有
          Object o=f.get(c1.newInstance());
          System.out.println(o);
    }
    //获取字段private static int  age=23;
    @Test
    public void test3() throws Exception{
        
        Class c1=Class.forName("refelect.Person");//加载类
        Field f= c1.getDeclaredField("age");
        f.setAccessible(true);//暴力修改字段的可视性为公有
        Object o=f.get(c1.newInstance());
        System.out.println(o);
    }
    //获取字段public static int  score=90;
    @Test
    public void test4() throws Exception{
        
        Class c1=Class.forName("refelect.Person");//加载类
        Field f= c1.getField("score");
//        Object o=f.get(c1.newInstance());
        System.out.println(f.get(c1.newInstance()));
    }
}

 

 6. 内省(Introspector)

6.1 为什么要学习内省

开发框架时，经常需要使用java对象的属性来封装程序的数据，每次都使用反射技术完成此类操作过于麻烦，所以sun公司开发了一套API，专门用于操作java对象的属性

6.2 通过内省操作javabean属性

package refelect;

/**
 * Person就是一个javabean 
 * 里面的字段有对应的get或者set方法，这个字段就称为一个属性
 * 
 * @author lgs
 *
 */
public class Person {

    // 字段
    public String name;

    // 字段
    private int password;

    // 字段
    private int age;

    // 字段
    private int score;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getPassword() {
        return password;
    }

    public void setPassword(int password) {
        this.password = password;
    }

    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;
    }

}

 

package introspector;

import java.beans.BeanInfo;
import java.beans.IntrospectionException;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Method;

import org.junit.Test;

//通过内省来操作bean(即Person类)的属性
public class TestIntroSpector {
    
    //获取bean的所有属性
    @Test
    public void test1() throws Exception{
        //BeanInfo bi=Introspector.getBeanInfo(Person.class);//通过内省Introspector的getBeanInfo(Person.class)方法获取bean的所有属性
        BeanInfo bi=Introspector.getBeanInfo(Person.class, Object.class);//只获取本身增加的属性，不要从Object类获取的属性 与使用getDisplayName()方法的效果一样
        PropertyDescriptor [] pd=bi.getPropertyDescriptors();//读取bean的所有属性存到数组pd里面去
        for(PropertyDescriptor k:pd){
            System.out.println(k.getName());
            
        }
        
    }
    
    //获取并操作bean指定的属性 age
    @Test
    public void test2() throws Exception{
        Person p=new Person();
        //使用构造函数 PropertyDescriptor(String 属性名, 对应的bean)操作特定属性
        PropertyDescriptor pd=new PropertyDescriptor("age", Person.class);
        
        //获取属性的写方法,并为属性赋值
        Method m=pd.getWriteMethod();//获取bean的setAge属性 public void setAge(int age)
        m.invoke(p, 23);//执行SetAge属性并写入属性值
        
        //传统方式获取属性的值
        System.out.println(p.getAge());
        
        //内省获取属性的值
        Method mt=pd.getReadMethod();//获取getAge()方法 读属性值
        System.out.println(mt.invoke(p, null));//输出属性值
        
    }
    //获取bean指定的属性的类型 age
    @Test
    public void test3() throws Exception{
        Person p=new Person();
        //使用构造函数 PropertyDescriptor(String 属性名, 对应的bean)操作特定属性
        PropertyDescriptor pd=new PropertyDescriptor("age", Person.class);
        System.out.println(pd.getPropertyType());//获取age属性的类型
        
        
    }

}

 7. 泛型

7.1 使用泛型(generic)的好处

    使用泛型的好处可以进行类型安全检查，提高了程序的可读性和稳定性

package generic;

import java.util.ArrayList;
import java.util.List;

import org.junit.Test;

public class TestGeneric {

    //使用泛型的好处
    @Test
    public void test1() {
        // TODO Auto-generated method stub
        // 1、最原始的集合
        List l = new ArrayList();
        l.add("aaa");
        // 此时集合中的值明显是一个字符串，但程序员却把字符串转为Integer 编译不会出错但运行会错,相当不安全
        // Integer i=(Integer) l.get(0);

        // 使用泛型的好处
        // 2、定义集合时就利用泛型指定其处理的类型 这样做提高了程序的可读性和稳定性,同时 进行类型安全检查
        List l1 = new ArrayList();
        // l1.add(1);//使用泛型的好处可以进行类型安全检查 因为指定的泛型是String，所以传入的值必须为字符串
        l1.add("1");
        System.out.println(l1.get(0));

    }

}

7.2 泛型与集合搭配使用及其注意事项

       泛型是给java编译器(javac)使用的;防止在编译阶段向集合插入非法数据，当编译完以后，编译后的class文件不具有泛型信息，所以不影响运行效力，这个过程称之为“擦除”

package generic;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

import org.junit.Test;

public class TestGeneric {

    //使用泛型的好处
    @Test
    public void test1() {
        // TODO Auto-generated method stub
        // 1、最原始的集合
        List l = new ArrayList();
        l.add("aaa");
        // 此时集合中的值明显是一个字符串，但程序员却把字符串转为Integer 编译不会出错但运行会错,相当不安全
        // Integer i=(Integer) l.get(0);

        // 使用泛型的好处
        // 2、定义集合时就利用泛型指定其处理的类型 这样做提高了程序的可读性和稳定性,同时 进行类型安全检查
        List l1 = new ArrayList();
        // l1.add(1);//使用泛型的好处可以进行类型安全检查 因为指定的泛型是String，所以传入的值必须为字符串
        l1.add("1");
        System.out.println(l1.get(0));

    }
    //集合的存取
    @Test
    public void test2() {
        // TODO Auto-generated method stub
        
        List l1 = new ArrayList();
        // l1.add(1);//使用泛型的好处可以进行类型安全检查 因为指定的泛型是String，所以传入的值必须为字符串
        //集合的存
        l1.add("1");
        l1.add("2");
        l1.add("3");
        //集合的取
        //1、传统方案：使用迭代器
        System.out.println("-------1、传统方案：使用迭代器-----");
        Iterator it=l1.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
        //2、增强for循环
        System.out.println("-------2、增强for循环-----");
        for(String s:l1){
            System.out.println(s);
        }
        
    }
    
    //Map集合的存取
    @Test
    public void test3(){
        Map m=new HashMap();
        //Map的存
        m.put(1, "aa");
        m.put(2, "bb");
        m.put(3, "cc");
        //Map的取
        //传统方式1：keySet;
        System.out.println("-------传统方式1：keySet-------");
        Set s=m.keySet();
        Iterator it=s.iterator();
        while(it.hasNext()){
            int i=it.next();
            System.out.println(i+" "+m.get(i));
        }
        
        //传统方式2：entrySet 常用
        System.out.println("-------传统方式2：entrySet-------");
        Set> se=m.entrySet();
        Iterator> ite=se.iterator();
        while(ite.hasNext()){
            Entry e=ite.next();
            System.out.println(e.getKey()+" "+e.getValue());
        }
        
        //增强for循环 j2ee里面常用的方式(重点)
        System.out.println("-------增强for循环-------");
        for(Entry e:m.entrySet()){
            System.out.println(e.getKey()+" "+e.getValue());
        }
    }
    //使用泛型时应该注意的问题
    @Test
    public void test4(){
        //注意：当集合两边都使用泛型时，两边的泛型类型必须一致，否则会报错
        //但是如果只有一边使用泛型是是可以的
        
        //两边都使用泛型
        ArrayList al=new ArrayList();
        //ArrayList al=new ArrayList();
        //ArrayList al2=new ArrayList();
        
        //只有一边使用泛型
        ArrayList al3=new ArrayList();
        ArrayList al4=new ArrayList();
        
        //提高阶段：泛型是给java编译器(javac)使用的;防止在编译阶段向集合插入非法数据，
        //当编译完以后，编译后的class文件不具有泛型信息，所以不影响运行效力，这个过程称之为“擦除”
        //如l1和l2编译成class文件以后，除了变量名称不一样，其他的是完全一样的
        List l1 = new ArrayList();
        List l2 = new ArrayList();
    }

} 
  
7.3 自定义泛型
 
  
定义泛型方法：泛型遵循先声明再使用的规则
 
  
第一种方式：常规方法
 
  
package generic;

//定义泛型方法
public class DefineGenericMetgod {
    
    public void testaa(){
        aa("aa");//传入的是字符串，就确定了泛型类型为String，就不存在类型强转的情况(这就是泛型的真正意义)
    }
    //泛型遵循先声明再使用的规则
    public  void aa(T t){
        
    }
    public  void bb(T t,K k,E e){
        
    }

}
 
  
第二种方式：一个泛型作用于多个方法时可以把泛型声明在类上
 
  
package generic;

//定义泛型方法
//当一个泛型作用于多个方法时可以把泛型声明在类上
public class DefineGenericMetgod2 {
    
    public void testaa(){
        //aa("aa");//传入的是字符串，就确定了泛型类型为String，就不存在类型强转的情况(这就是泛型的真正意义)
    }
    //泛型遵循先声明再使用的规则
    public  T aa(T t){
        return t;
        
    }
    public  void bb(T t,K k,E e){
        
    }
    //类上的泛型对静态方法不起作用，要重新自定义自己的泛型,注意这个泛型T和类上的泛型T不是同一个
    public static void cc(T t){
        
    }

}
 
  
7.4 练习
 
  
(1) 编写一个泛型方法，交换指定数组元素的位置,记住:一定要使用泛型T定义方法，不能使用诸如String，int子类的类型，那样的话就只能交换一种特定类型的数组
 
  
public  void swap(T arr[], int pos1, int pos2) {
        T temp;
        temp = arr[pos1];
        arr[pos1] = arr[pos2];
        arr[pos2] = temp;
    }

    @Test
    public void testSwap() {
        Integer[] i = new Integer[] { 1, 2, 3, 4, 5 };
        System.out.println("-----交换之前-----");
        for (Integer k : i) {
            System.out.println(k);
        }
        swap(i, 1, 3);
        System.out.println("-----交换之后-----");
        for (Integer k : i) {
            System.out.println(k);
        }

    }
 
  
2) 编写一个泛型方法，接收任意数组，然后颠倒数组里面的元素
 
  
     思路:定义两个指针，第一个指针指向数组的第一个元素，第二个指针指向数组的最后一个元素，把两个元素交换，然后把第一个指针加1，第二个指针减1，再交换，如此进行下去知道两个指针的值相同时不在进行交换
 
  
public  void reverse(T arr[]) {
        int first = 0;
        int last = arr.length - 1;

        while (true) {
            if (first >= last) {
                break;
            }
            T temp;
            temp = arr[first];
            arr[first] = arr[last];
            arr[last]=temp;
            first++;
            last--;
        }
    }

    @Test
    public void testReverse() {
        Integer[] i = new Integer[] { 1, 2, 3, 4, 5 };
        System.out.println("-----颠倒之前-----");
        for (Integer k : i) {
            System.out.println(k);
        }
        reverse(i);
        System.out.println("-----颠倒之后-----");
        for (Integer k : i) {
            System.out.println(k);
        }
    }
 
  
 
 
  
 
 
  
 
 
  
 
 
  
 
 
  
 
 
  
 
 
  
 
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(Java基础)

        

            

                
    
                    
  • JAVA·一个简单的登录窗口
                        MortalTom
java开发语言学习
                        
    文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计
    
                    
    • 
                    
  • 互联网 Java 工程师面试题（Java 面试题四）
                        苹果酱0567
面试题汇总与解析java中间件开发语言springboot后端
                        
    下面列出这份Java面试问题列表包含的主题多线程，并发及线程基础数据类型转换的基本原则垃圾回收（GC）Java集合框架数组字符串GOF设计模式SOLID抽象类与接口Java基础，如equals和hashcode泛型与枚举JavaIO与NIO常用网络协议Java中的数据结构和算法正则表达式JVM底层Java最佳实JDBCDate,Time与CalendarJava处理XMLJUnit编程现在是时候给
    
                    
    • 
                    
  • JAVA相关知识
                        M_灵均
javajvm开发语言
                        
    JAVA基础知识说一下对象创建的过程？类加载检查：当Java虚拟机（JVM）遇到一个类的new指令时，它首先检查这个类是否已经被加载、链接和初始化。如果没有，JVM会通过类加载器（ClassLoader）加载这个类。分配内存：JVM为新对象分配内存。这个内存分配是在堆（Heap）上进行的，堆是JVM用来存储对象实例的地方。分配内存的大小在类加载时就已经确定，因为类的结构（包括字段和方法）已经确定。
    
                    
    • 
                    
  • 字节跳动面试官亲述：Android开发学会了这些技术，你离大厂不远了
                        m0_65322636
程序员架构移动开发android
                        
    HTTPSHTTP是超文本传输协议，明文传输；HTTPS使用SSL协议对HTTP传输数据进行了加密HTTP默认80端口；HTTPS默认443端口优点：安全缺点：费时、SSL证书收费，加密能力还是有限的，但是比HTTP强多了2、Java基础&容器&同步&设计模式StringBuilder、StringBuffer、+、String.concat链接字符串：StringBuffer线程安全，Strin
    
                    
    • 
                    
  • Java基础一
                        十一路客
java开发语言
                        
    哔哩哔哩Java开发工程师面试该如（）何准备？-知乎一.JavaOOP面试题(1)什么是B/S架构?什么是C/S架构Java都有那些开发平台?B/S(Browser/Server)，浏览器/服务器程序C/S(Client/Server)，客户端/服务端，桌面应用程序1、C/S和B/S各有优势，C/S在图形的表现能力上以及运行的速度上肯定是强于B/S模式的，不过缺点就是他需要运行专门的客户端，而且更
    
                    
    • 
                    
  • Java 学习路线：语言、框架、中间件与数据库
                        高危型
java
                        
    Java是一门功能强大、应用广泛的编程语言，适用于企业级应用、Web开发、大数据处理、Android开发等各种场景。这里为大家介绍了一下我认为较为合适的学习路线一、Java基础1.1Java语言基础1.1.1安装JDK和IDE安装JDK：下载JDK：访问Oracle官网，下载最新的JavaDevelopmentKit（JDK）。安装JDK：按照操作系统要求安装JDK并配置环境变量。Windows上
    
                    
    • 
                    
  • java基础-线程间通信方式
                        问道飞鱼
Java开发技术java开发语言
                        
    文章目录1.wait()和notify()2.volatile关键字3.Java.util.concurrent包提供的工具类Semaphore（信号量）BlockingQueue（阻塞队列）4.Atomic类在Java中，线程间的通信是非常重要的，尤其是在多线程编程中，它有助于协调线程的行为，确保资源的正确访问和更新。Java提供了多种方式来实现线程间的通信，主要包括以下几种方法：1.wait(
    
                    
    • 
                    
  • Java并发复习
                        vd_vd
Java并发安全容器java开发语言
                        
    Java基础1.为什么要使用并发编程？一般我们工作的电脑都有多核，我们创建多个线程，然后操作系统可以将多个线程分配给不同的CPU去执行，每个CPU执行一个线程，这样就提高了CPU使用效率。在网络购物中，我们买了一个东西的同时，需要减库存，生成订单等等这些操作，就可以进行拆分利用多线程的技术完成。面对复杂业务模型，并行程序串行会比程序更适应业务需求，而并发编程更能吻合这种业务拆分。->充分利用多核C
    
                    
    • 
                    
  • Android 高频面试必问之Java基础
                        2401_86022611
android面试java
                        
    常用的JVM调参如下表：|参数|作用描述||—|—||-XX:MetaspaceSize|分配给Metaspace（以字节计）的初始大小。如果不设置的话，默认是20.79M，这个初始大小是触发首次MetaspaceFullGC的阈值，例如-XX:MetaspaceSize=256M||-XX:MaxMetaspaceSize|分配给Metaspace的最大值，超过此值就会触发FullGC，此值默认
    
                    
    • 
                    
  • Java基础day08ArrayList和继承
                        没有信仰的小白

                        
    ArrayList类对象数组数组长度是固定，无动态扩容java.util.ArrayList集合类，更方便image无参构造函数image基本格式,Jdk7之后右侧尖括号可以留空，但是必须保留ArrayListlist=newArrayList<>();成员方法添加元素publicbooleanadd(Ee)获取元素publicEget(intindex)集合中的元素publicintsize()
    
                    
    • 
                    
  • java基础系列02--面向对象
                        addin_gao

                        
    java面向对象封装(encapsulation)继承(inheritance)多态(polymorphism)成员变量和局部变量的区别：在类中的位置不同:成员变量：在类中方法外局部变量：在方法定义中或者方法声明上在内存中的位置不同:成员变量：在堆内存(成员变量属于对象,对象进堆内存)局部变量：在栈内存(局部变量属于方法,方法进栈内存)生命周期不同:成员变量：随着对象的创建而存在，随着对象的消失而
    
                    
    • 
                    
  • Java基础全程学习笔记（二）
                        网路侠客
java学习笔记开发语言
                        
    第06章：面向对象-基础#面向对象内容的三条主线：>类及类的内部成员：属性、方法、构造器;代码块、内部类>面向对象的三大特征：封装性、继承性、多态性>其它关键字的使用：package、import、this、super、static、final、abstract、interface等1.理解：面向过程vs面向对象#简单的语言描述二者的区别>面向过程：以`函数`为组织单位。是一种“`执行者思维`”，
    
                    
    • 
                    
  • Java基础：什么是多态
                        试着奔跑的菜鸟
javajava开发语言
                        
    什么是多态多态是面向对象的三大特性之一（另外两个是封装和继承），指的是同一个方法能执行不同的行为，在代码上的体现是：声明为父类的对象，可以被不同的实现类赋值，其中实现类必须继承或者实现父类接口，然后程序在运行时会执行实现类的方法。//如ArrayList和LinkedList都实现了List接口classArrayListimplementsList{}classLinkedListimpleme
    
                    
    • 
                    
  • java基础之继承
                        Absinthe_苦艾酒
java开发语言
                        
    1.一个子类只能有一个直接父类（一个父类可以多个子类）2.private修饰符和void不能继承、不同包不能继承代码如下：父类packagebegan;//定义一个父类publicclassPet01{//属性publicStringname;//方法publicvoidrun(Stringname){System.out.println(name+"running");}}子类packagebe
    
                    
    • 
                    
  • Java基础 --- 多线程&JUC，以及一些常用的设计模式总结
                        lzhlizihang
java设计模式
                        
    文章目录一、多线程1、线程和进程的区别2、创建多线程的四种方式3、集合中的线程安全二、设计模式1、单例模式2、装饰者模式（IO流缓冲流）3、适配器模式4、模板模式一、多线程1、线程和进程的区别进程是操作系统资源分配的基本单位，而线程是处理器任务调度和执行的基本单位，一个进程可以运行多个线程多进程：操作系统中同时运行的多个程序多线程：在同一个进程中同时运行的多个任务2、创建多线程的四种方式Runna
    
                    
    • 
                    
  • Java学习路线：从零基础到高级开发者的完整指南
                        何遇mirror
java
                        
    初学者入门指南1.环境搭建安装JDK:下载并安装最新版本的JDK（JavaDevelopmentKit）。配置环境:设置JAVA_HOME环境变量，并将bin目录添加到PATH中。选择IDE:使用Eclipse、IntelliJIDEA或其他任何你喜欢的Java集成开发环境。2.Java基础知识HelloWorld:编写你的第一个Java程序。基本语法:学习变量、数据类型（原始类型、包装类型）、运
    
                    
    • 
                    
  • Java 学习路线：适合小白的超细学习路线及实例代码
                        Dreams°123
后端javaeclipsejvmspringtomcatideintellij-idea
                        
    Java学习路线：适合小白的超细学习路线及实例代码一、入门基础1.1、Java基础语法1.2、面向对象编程(OOP)二、核心Java编程2.1、数据结构和算法基础2.2、输入输出(I/O)三、进阶Java编程3.1、多线程编程3.2、网络编程四、高级应用4.1、数据库编程4.2、Web开发4.3、框架与库五、实践项目与进阶学习（留作业啦）5.1、实践项目5.2、持续学习一、入门基础1.1、Java
    
                    
    • 
                    
  • Java基础：单例模式，Spring源码中有哪些单例模式
                        生活诙谐号
Java基础Spring源码设计模式单例模式javaspring
                        
    单例模式是一种常用的软件设计模式，其目的是确保一个类仅有一个实例，并提供一个全局访问点来获取这个唯一实例。在Java中，实现单例模式通常需要遵循以下几个关键原则：私有化构造器：将类的构造器声明为private，以防止外部代码通过new操作符直接创建该类的实例。静态工厂方法：提供一个静态方法（通常称为getInstance()），用于获取单例对象。这个方法负责检查是否已经创建过实例，如果尚未创建，则
    
                    
    • 
                    
  • 多线程 03：知识补充，静态代理与 Lambda 表达式的相关介绍，及其在多线程方面的应用
                        蟾宫曲
Java多线程java开发语言多线程静态代理Lambdaintellij-idea
                        
    一、概述记录时间[2024-08-16]前置知识：Java基础篇；Java面向对象多线程01：Java多线程学习导航，线程简介，线程相关概念的整理多线程02：线程实现，创建线程的三种方式，通过多线程下载图片案例分析异同（Thread，Runnable，Callable）Java多线程学习主要模块包括：线程简介；线程实现；线程控制；线程状态；线程同步；线程通信问题；拓展高级主题。本文是针对多线程的相
    
                    
    • 
                    
  • Java基础之Java中的8种基本数据类型
                        w乐生
乐生的Java之路java
                        
    一，8种基本数据类型1，byte：8位1字节，取值范围：2-7----27-12，shot：16位2字节，取值范围：2-15----215-13，int：32位4字节，取值范围：2-31----231-14，long：64位8字节，取值范围：2-63----263-15，float：32位4字节，取值范围：-2-31----231-16，double：64位8字节，取值范围：-2-63----26
    
                    
    • 
                    
  • Java学习路线
                        纣王家子迎新
javajava学习
                        
    一、Java基础阶段‌Java语言基础‌：数据类型与变量：了解Java中的基本数据类型（如int、float、double等）和引用数据类型，掌握变量的声明、初始化和使用。运算符与表达式：学习Java中的算术运算符、关系运算符、逻辑运算符等，以及它们的使用规则和优先级。流程控制：掌握条件语句（if-else）、循环语句（for、while、do-while）和跳转语句（break、continue
    
                    
    • 
                    
  • 2024上学期--实验室学习计划
                        m0_66357705
javascript前端vue.js
                        
    阶段周次学习内容实践内容时间安排新增内容/重点基础巩固1-2周Java基础，多线程，TCP/IP网络编程相关练习和小的编程项目每天学习2小时，实践1小时Java20及以上版本新特性学习框架深入学习3-6周Spring，SpringBoot相关练习和小的编程项目每天学习3小时，实践1.5小时学习SpringCloud和微服务架构基础前端技术提升7-8周Vue2，Vue3相关练习和小的编程项目每天学习
    
                    
    • 
                    
  • Java基础——深入理解Java中的多线程（超级详细，值得你看）
                        2401_84558508
作者\/java开发语言
                        
    开发中优先选择实现Runnable方式原因：实现的方式没有类的单继承性的局限性实现的方式更适合来处理多个线程共享数据的情况相同点：都需要重写run()，将线程要执行的代码声明在run()方法中线程的生命周期解决线程安全问题；使用同步代码块packagecom.haust.java;/*出现线程安全问他的解决方法：当一个线程a在操作ticket的时候，其他线程不能参与进来，直到线程参与进来，也操作完
    
                    
    • 
                    
  • 庖丁解java(一篇文章学java)
                        庖丁解java
java开发语言
                        
    (大家不用收藏这篇文章,因为这篇文章会经常更新,也就是删除后重发)一篇文章学java,这是我滴一个执念...当然,真一篇文章就写完java基础,java架构,java业务实现,java业务扩展,根本不可能.所以,这篇文章,就是一个索引,索什么呢?请看下文.关于决定开始写博文的介绍(一切故事的起点源于这一次反省)中小技术公司的软扩展(微服务扩展是否有必要?)-CSDN博客SpringCloud(一个
    
                    
    • 
                    
  • Java基础 -- 05反射reflect
                        mmlz00
Java基础Java基础反射reflectProxy动态代理
                        
    目录引序说不通1：注解说不通2：匿名内部类说不通3：动态代理反射：反射定义强调：类对象又强调：static类静态成员再三强调：synchronized修饰符类对象：知晓类结构类结构之：内部成员内部成员--构造函数内部成员--数据成员内部成员--方法成员静态代理：动态代理：反射+注解反射+泛型+注解getGenericSuperclass()用法引序引序：开始反射概念学习之前，先来段引序。请牢记：计
    
                    
    • 
                    
  • 从零开始学习Java的100个课程
                        陈在天box
java大数据开发语言
                        
    哈喽大家好，今天给大家推荐的是从零开始学习Java的100个课程，接下来我会每天更新两篇课程经验供大家参考学习；以下是为大家设计的从零开始学习Java的100个课程：一、Java基础语法Java开发环境搭建安装JDK配置环境变量编写并运行第一个Java程序基本数据类型整数类型（byte、short、int、long）浮点类型（float、double）字符类型（char）布尔类型（boolean）
    
                    
    • 
                    
  • java基础知识
                        阿拉伯的劳伦斯292
java开发语言
                        
    1.java简介跨平台性：Java语言的“一次编写，到处运行”特性是这一语言的重要优势,java程序编译成字节码，可以在安装了Java虚拟机（JVM，javavirtualmachine）的不同操作系统上运行面向对象：java是一门完全的面向对象编程语言，支持继承，抽象，封装和多态的特性内存管理：java通过垃圾回收器（GarbageCollector）自动管理内存，这就不用开发者手动释放内存了，
    
                    
    • 
                    
  • 2025届美团秋招笔试题
                        今天不coding
python算法开发语言
                        
    题型及时间90分钟单选10+算法3单选包括Java基础八股文、设计模式、计算机网络、sql语句算法1题目描述小美准备登录美团，需要输入密码，小美忘记了密码,只记得密码可能是n个字符串中的一个。小美会按照密码的长度从小到大依次尝试每个字符串，对于相同长度的字符串，小美随机尝试，并且相同的密码只会尝试一次。小美想知道，她最少需要尝试多少次才能登录成功，最多需要尝试多少次才能登录成功。小美不会重新尝试已
    
                    
    • 
                    
  • gee mysql数据库_MySQL
                        weixin_39955142
geemysql数据库
                        
    集合如果你有更好的想法请在评论区留下您的答案，一起交流讨论说说常见的集合有哪些？答：主要分List、Set、Map、Queue四类，其中包含ArrayList、LinkedList、HashSet、TreeSet、HashMapComparable和Comparator接口的区别？答：其两...»smart-rick2021-02-15JAVA基础面向对象有哪些特征？答：继承、封装、多态JDK与J
    
                    
    • 
                    
  • 2019-03-26Day02 java基础语法01
                        summericy

                        
    Day02java基础语法1.关键字：被Java语言赋予特殊含义的单词特点：字母小写注意void是一种特殊的数据类型（空类型）标识符:给类，接口，方法，变量起名字使用的序列组成:大小写，数字下划线_美元符号$特点;1.不以数字开头2.不能是Java关键字3.严格区分大小写最好见名知义常见规则包（其实就是文件夹，解决相同类名）划分命名空间，包名+类名单级:全部小写多级：全部小写且域名要反转类和接口一
    
                    
    • 
                                
  • ASM系列五 利用TreeApi 解析生成Class
                                    lijingyao8206
ASM字节码动态生成ClassNodeTreeAPI
                                    
       前面CoreApi的介绍部分基本涵盖了ASMCore包下面的主要API及功能，其中还有一部分关于MetaData的解析和生成就不再赘述。这篇开始介绍ASM另一部分主要的Api。TreeApi。这一部分源码是关联的asm-tree-5.0.4的版本。 
         在介绍前，先要知道一点， Tree工程的接口基本可以完
    
                                
    • 
                                
  • 链表树——复合数据结构应用实例
                                    bardo
数据结构树型结构表结构设计链表菜单排序
                                    
    我们清楚：数据库设计中，表结构设计的好坏，直接影响程序的复杂度。所以，本文就无限级分类（目录）树与链表的复合在表设计中的应用进行探讨。当然，什么是树，什么是链表，这里不作介绍。有兴趣可以去看相关的教材。 
需求简介： 
经常遇到这样的需求，我们希望能将保存在数据库中的树结构能够按确定的顺序读出来。比如，多级菜单、组织结构、商品分类。更具体的，我们希望某个二级菜单在这一级别中就是第一个。虽然它是最后
    
                                
    • 
                                
  • 为啥要用位运算代替取模呢
                                    chenchao051
位运算哈希汇编
                                    
      
  在hash中查找key的时候，经常会发现用&取代%，先看两段代码吧， 
  
  JDK6中的HashMap中的indexFor方法： 
    /**
     * Returns index for hash code h.
     */
    static int indexFor(int h, int length) {

    
                                
    • 
                                
  • 最近的情况
                                    麦田的设计者
生活感悟计划软考想
                                    
          今天是2015年4月27号 
     整理一下最近的思绪以及要完成的任务 
            1、最近在驾校科目二练车，每周四天，练三周。其实做什么都要用心，追求合理的途径解决。为
    
                                
    • 
                                
  • PHP去掉字符串中最后一个字符的方法
                                    IT独行者
PHP字符串
                                    
    今天在PHP项目开发中遇到一个需求，去掉字符串中的最后一个字符 原字符串1,2,3,4,5,6, 去掉最后一个字符","，最终结果为1,2,3,4,5,6 代码如下： 
$str = "1,2,3,4,5,6,";
$newstr = substr($str,0,strlen($str)-1);
echo $newstr; 
    
                                
    • 
                                
  • hadoop在linux上单机安装过程
                                    _wy_
linuxhadoop
                                    
    1、安装JDK 
    jdk版本最好是1.6以上，可以使用执行命令java -version查看当前JAVA版本号，如果报命令不存在或版本比较低，则需要安装一个高版本的JDK，并在/etc/profile的文件末尾，根据本机JDK实际的安装位置加上以下几行： 
   export JAVA_HOME=/usr/java/jdk1.7.0_25  
    
                                
    • 
                                
  • JAVA进阶----分布式事务的一种简单处理方法
                                    无量
多系统交互分布式事务
                                    
    每个方法都是原子操作： 
 
提供第三方服务的系统，要同时提供执行方法和对应的回滚方法 
 
A系统调用B,C,D系统完成分布式事务 
 
 
=========执行开始======== 
A.aa(); 
 
try { 
 B.bb(); 
} catch(Exception e) { 
 A.rollbackAa(); 
} 
 
try { 
 C.cc(); 
} catch(Excep
    
                                
    • 
                                
  • 安墨移动广 告：移动DSP厚积薄发 引领未来广 告业发展命脉
                                    矮蛋蛋
hadoop互联网
                                    
    　　“谁掌握了强大的DSP技术，谁将引领未来的广 告行业发展命脉。”2014年，移动广 告行业的热点非移动DSP莫属。各个圈子都在纷纷谈论，认为移动DSP是行业突破点，一时间许多移动广 告联盟风起云涌，竞相推出专属移动DSP产品。 
 
　　到底什么是移动DSP呢? 
 
　　DSP(Demand-SidePlatform)，就是需求方平台，为解决广 告主投放的各种需求，真正实现人群定位的精准广 
    
                                
    • 
                                
  • myelipse设置
                                    alafqq
IP
                                    
      在一个项目的完整的生命周期中，其维护费用，往往是其开发费用的数倍。因此项目的可维护性、可复用性是衡量一个项目好坏的关键。而注释则是可维护性中必不可少的一环。 
 
 
 
注释模板导入步骤  
 
 
 
安装方法： 
打开eclipse/myeclipse 
选择 window-->Preferences-->JAVA-->Code-->Code 
    
                                
    • 
                                
  • java数组
                                    百合不是茶
java数组
                                    
    java数组的   声明  创建  初始化；   java支持C语言 
   
  
数组中的每个数都有唯一的一个下标 
  一维数组的定义   声明：  int[] a = new int[3];声明数组中有三个数int[3]    
int[] a 中有三个数，下标从0开始，可以同过for来遍历数组中的数


    
                                
    • 
                                
  • javascript读取表单数据
                                    bijian1013
JavaScript
                                    
    利用javascript读取表单数据，可以利用以下三种方法获取： 
1、通过表单ID属性：var a = document.getElementByIdx_x_x("id"); 
2、通过表单名称属性：var b = document.getElementsByName("name"); 
3、直接通过表单名字获取：var c = form.content.
    
                                
    • 
                                
  • 探索JUnit4扩展：使用Theory
                                    bijian1013
javaJUnitTheory
                                    
    理论机制（Theory） 
一.为什么要引用理论机制（Theory） 
        当今软件开发中，测试驱动开发（TDD — Test-driven development）越发流行。为什么 TDD 会如此流行呢？因为它确实拥有很多优点，它允许开发人员通过简单的例子来指定和表明他们代码的行为意图。 
TDD 的优点： 
    &nb
    
                                
    • 
                                
  • [Spring Data Mongo一]Spring Mongo Template操作MongoDB
                                    bit1129
template
                                    
    什么是Spring Data Mongo 
Spring Data MongoDB项目对访问MongoDB的Java客户端API进行了封装，这种封装类似于Spring封装Hibernate和JDBC而提供的HibernateTemplate和JDBCTemplate，主要能力包括 
1. 封装客户端跟MongoDB的链接管理 
2. 文档-对象映射，通过注解:@Document(collectio
    
                                
    • 
                                
  • 【Kafka八】Zookeeper上关于Kafka的配置信息
                                    bit1129
zookeeper
                                    
    问题： 
1. Kafka的哪些信息记录在Zookeeper中 2. Consumer Group消费的每个Partition的Offset信息存放在什么位置 
3. Topic的每个Partition存放在哪个Broker上的信息存放在哪里 
4. Producer跟Zookeeper究竟有没有关系？没有关系！！！ 
  
//consumers、config、brokers、cont
    
                                
    • 
                                
  • java OOM内存异常的四种类型及异常与解决方案
                                    ronin47
java OOM 内存异常
                                    
          　OOM异常的四种类型： 
　　　 
　　一：　StackOverflowError ：通常因为递归函数引起（死递归，递归太深）。-Xss 128k 一般够用。 
  
  　  二：　out Of memory: PermGen Space：通常是动态类大多，比如web 服务器自动更新部署时引起。-Xmx
    
                                
    • 
                                
  • java-实现链表反转-递归和非递归实现
                                    bylijinnan
java
                                    
    20120422更新： 
对链表中部分节点进行反转操作，这些节点相隔k个： 
0->1->2->3->4->5->6->7->8->9 
k=2 
8->1->6->3->4->5->2->7->0->9 
注意1 3 5 7 9 位置是不变的。 
解法： 
将链表拆成两部分： 
a.0-&
    
                                
    • 
                                
  • Netty源码学习-DelimiterBasedFrameDecoder
                                    bylijinnan
javanetty
                                    
     看DelimiterBasedFrameDecoder的API，有举例： 
 接收到的ChannelBuffer如下： 
 
 +--------------+
 | ABC\nDEF\r\n |
 +--------------+ 
 经过DelimiterBasedFrameDecoder(Delimiters.lineDelimiter())之后，得到： 
 
 +-----+----
    
                                
    • 
                                
  • linux的一些命令 -查看cc攻击-网口ip统计等
                                    hotsunshine
linux
                                    
    Linux判断CC攻击命令详解 
2011年12月23日 ⁄ 安全 ⁄ 暂无评论 
查看所有80端口的连接数 
 
 
netstat -nat|grep -i '80'|wc -l
对连接的IP按连接数量进行排序

netstat -ntu | awk '{print $5}' | cut -d: -f1 | sort | uniq -c | sort -n
查看TCP连接状态

n
    
                                
    • 
                                
  • Spring获取SessionFactory
                                    ctrain
sessionFactory
                                    
    
String sql = "select sysdate from dual";
		
WebApplicationContext wac = ContextLoader.getCurrentWebApplicationContext(); 
String[] names = wac.getBeanDefinitionNames();
for(int i=0; i&
    
                                
    • 
                                
  • Hive几种导出数据方式
                                    daizj
hive数据导出
                                    
    Hive几种导出数据方式 
     
1.拷贝文件 
  
如果数据文件恰好是用户需要的格式，那么只需要拷贝文件或文件夹就可以。 
hadoop fs –cp source_path target_path 
  
2.导出到本地文件系统 
  
--不能使用insert into local directory来导出数据，会报错 
--只能使用
    
                                
    • 
                                
  • 编程之美
                                    dcj3sjt126com
编程PHP重构
                                    
    我个人的 PHP 编程经验中，递归调用常常与静态变量使用。静态变量的含义可以参考 PHP 手册。希望下面的代码，会更有利于对递归以及静态变量的理解 
  
header("Content-type: text/plain");
function static_function () {
    static $i = 0;
    if ($i++ < 1
    
                                
    • 
                                
  • Android保存用户名和密码
                                    dcj3sjt126com
android
                                    
    转自：http://www.2cto.com/kf/201401/272336.html 
我们不管在开发一个项目或者使用别人的项目，都有用户登录功能，为了让用户的体验效果更好，我们通常会做一个功能，叫做保存用户，这样做的目地就是为了让用户下一次再使用该程序不会重新输入用户名和密码，这里我使用3种方式来存储用户名和密码 
1、通过普通 的txt文本存储 
2、通过properties属性文件进行存
    
                                
    • 
                                
  • Oracle 复习笔记之同义词
                                    eksliang
Oracle 同义词Oracle synonym
                                    
    转载请出自出处：http://eksliang.iteye.com/blog/2098861 
1.什么是同义词 
      同义词是现有模式对象的一个别名。 
      概念性的东西，什么是模式呢？创建一个用户，就相应的创建了 一个模式。模式是指数据库对象，是对用户所创建的数据对象的总称。模式对象包括表、视图、索引、同义词、序列、过
    
                                
    • 
                                
  • Ajax案例
                                    gongmeitao
Ajaxjsp
                                    
    数据库采用Sql Server2005 
项目名称为:Ajax_Demo 
1.com.demo.conn包 
package com.demo.conn; 
import java.sql.Connection;import java.sql.DriverManager;import java.sql.SQLException; 
//获取数据库连接的类public class DBConnec
    
                                
    • 
                                
  • ASP.NET中Request.RawUrl、Request.Url的区别
                                    hvt
.netWebC#asp.nethovertree
                                    
      
如果访问的地址是：http://h.keleyi.com/guestbook/addmessage.aspx?key=hovertree%3C&n=myslider#zonemenu那么Request.Url.ToString() 的值是：http://h.keleyi.com/guestbook/addmessage.aspx?key=hovertree<&
    
                                
    • 
                                
  • SVG 教程 （七）SVG 实例，SVG 参考手册
                                    天梯梦
svg
                                    
    SVG 实例   在线实例 
下面的例子是把SVG代码直接嵌入到HTML代码中。 
谷歌Chrome，火狐，Internet Explorer9，和Safari都支持。 
注意：下面的例子将不会在Opera运行，即使Opera支持SVG - 它也不支持SVG在HTML代码中直接使用。    SVG 实例 
SVG基本形状 
一个圆 
矩形 
不透明矩形 
一个矩形不透明2 
一个带圆角矩
    
                                
    • 
                                
  • 事务管理
                                    luyulong
javaspring编程事务
                                    
    事物管理 
 
spring事物的好处 
 
为不同的事物API提供了一致的编程模型 
支持声明式事务管理 
提供比大多数事务API更简单更易于使用的编程式事务管理API 
整合spring的各种数据访问抽象 
 
TransactionDefinition 
定义了事务策略 
 
int getIsolationLevel()得到当前事务的隔离级别 
 
READ_COMMITTED 
    
                                
    • 
                                
  • 基础数据结构和算法十一：Red-black binary search tree
                                    sunwinner
AlgorithmRed-black
                                    
      
The insertion algorithm for 2-3 trees just described is not difficult to understand; now, we will see that it is also not difficult to implement. We will consider a simple representation known
    
                                
    • 
                                
  • centos同步时间
                                    stunizhengjia
linux集群同步时间
                                    
    做了集群，时间的同步就显得非常必要了。 以下是查到的如何做时间同步。 在CentOS 5不再区分客户端和服务器，只要配置了NTP，它就会提供NTP服务。 1)确认已经ntp程序包： # yum install ntp 2)配置时间源（默认就行，不需要修改） # vi /etc/ntp.conf server pool.ntp.o
    
                                
    • 
                                
  • ITeye 9月技术图书有奖试读获奖名单公布
                                    ITeye管理员
ITeye
                                    
    ITeye携手博文视点举办的9月技术图书有奖试读活动已圆满结束，非常感谢广大用户对本次活动的关注与参与。 9月试读活动回顾：http://webmaster.iteye.com/blog/2118112本次技术图书试读活动的优秀奖获奖名单及相应作品如下（优秀文章有很多，但名额有限，没获奖并不代表不优秀）：  
  
  
《NFC：Arduino、Andro
    
                                
    •