java高级特性学习笔记

基本数据类型的装箱和拆箱

  Integer iobj=3;//装箱 相当于编译器自动完成 Integer i=new Integer(3);
  System.out.println(iobj+12);//拆箱 自动转化基本数据类型的过程

 

享元模式：就是有很多小的对象或方法，它们有很多相同的东西，那么我们就可以把相同的变成一个对象，并

              将哪些不同的东西变成外部的属性，作为方法的参数输入。
  

枚举：关键字是enum,可以看着是特殊的class,   可以有自己的变量，可以定义自己的方法，可以实现一个或者多个接口，不能有public的构造函数,所有的方法都必须放在元素列表之后

         但可以定义private的构造函数

        注意的是：所有枚举值都是public   ,   static   ,   final的。

eg://含抽象法的枚举

 public enum TrafficLamp{
  RED(20){
   public TrafficLamp nextLamp(){
    return GREEN;
     
   }
  }
  ,
  GREEN(20){
   public TrafficLamp nextLamp(){
    return YELLOW;
     
   
  }
  },
  YELLOW(15){
   public TrafficLamp nextLamp(){
  
   return RED;
   }
  }
  ;
  public abstract TrafficLamp nextLamp();
  private int time;
  private TrafficLamp(int time){this.time=time;};
  
 }

--------------------------------------------------------------------------

语言里的动态：一般指程序运行时，容许改变程序结构或变量类型，这种语言称为动态语言

 

Reflection,意思是“反射、映像、倒影”，在java中指的是我们可以在运行时加载、探知、使用编译期间完全未知的classes.

即：java程序可以加载运行一个运行时才得知名称的class，获悉其完整的构造，并生成其对象实体、或对其fields设值、

或唤起其methodsl.

 

反射的基石：Class类,用来表达Java程序运行时的classes和interfaces,也用来表达enum/array/private Java types（8个基本类）/关键词void。

                  当一个class被加载，或当加载器（class loader)的defineClass()被JVM调用，JVM便自动产生一个Class object.

 

                   java程序中的各个java类属于同一类事物，描述这类事物的java类名就是Class

                   字节码就是Class的实例对象

                       获得字节码的3种方法

                       pl.getClass();//pl指对象

                       Class.forName("类名"）//做反射主要用这种

                       Class cls=Person.class//得到Person实例的字节码

                         

                          Class cls1=字节码1；

                          Class cls2=字节码2；

数组类型的Class实例对象：Class.isArray():

总之：只要是在源程序中出现的类型，都有自己的Class实例对象。反射就是把一个java类中的各种成分映射（解析）

          为相应的java类，比如类中的方法通过反射就转换成Method的一个对象

要想得到一个类中的方法，我们要先得到该类的字节码，在通过getMethod方法得到该字节码中相应的方法

Constructor类代表某一类的构造方法 

反射会使性能下降

 

 

 

 正则表达式（符合某种规则的表达式）的作用：
                 测试字符串是否匹配某个模式，从而验证数据格式的有效性。
                 将一段文本中满足某一正则表达式的文本内容替换或删除。
                 在某一段文本中收索具有一类型特征的文本内容。
------------------------------------------------------------------
API(应用程序编程的接口）Application Programming Interface
作用：java api 就是jdk提供的各种java类
掌握了大量api对编程好处多多，体会编程的思想和方法
学习一门编程语言以够用为原则，但以学多少为标准呢？

Java开发工具软件的特点：集成编辑软件功能
                      使用工程化方式管理
                      产生不同应用程序的基本框架

String类和StringBuffer类（位于java.lang包中）
String类对象中的内容一旦被初始化就不能再改变
StringBurrer类用于封装可以改变的字符串。
用toString方法转化成String类型String="a"+4+"c"
编译时等效于String x=new StringBuffer(
).append("a").append(4).append("c").toString();

构造方法
String(byte[]bytes,int offset,int length)
equalslgnoreCase方法 不区分大小写
indexOf(int ch)用定位指定字符首次出现是位置

Vector类提供了一种与动态数组相近的功能，将数目不确定的对象保存

---------------------------------------------------------------
public class MyClass{
       private static String classVar="这是一个类变量"；
       private String instanVar="这是一个实例变量"；
   }
类变量被同一个类的所有实例共享；实例变量不在对象之间共享
被static关键字修饰的成员变量称为类变量（或静态变量）
前面无static标识的成员变量称为实例变量
访问实例变量需要先获得对象实例，访问类变量不能只需要指定类名
实例变量在对象创建是被初始化，在对象销毁时被销毁；类变量一旦创建就永驻内存

被static关键字修饰的方法称为静态方法（或类方法）
静态方法中不能使用this关键字
静态方法不能被覆盖
静态方法不需要使用对象来访问，可用“类名.方法名”
static方法不能访问非static的变量
main方法是static的
如果一个类的方法会被经常反复调用到，建议把这个方法声明为static
static 类方法无法进行动态联编，所以不便扩展
static修饰的初始化程序块为静态块

---------------------------------------------------------------
public class Count{
     private int serialNumber;
     private static int counter=0;
     public Count(){
            counter++;
            serialNumber=counter;
}

---------------------------------
public class GeneralFunction
{
  public static int addUp(int x,int y)
  {
   return x + y;
  }
  public class UseGeneral{
    public void method(){
           int c=GeneralFunction.addUp(9,10);
    }
 }
-----------------------------------------
public class MyClasss{
     static{
           System.out.println("这是一段静态初始化程序")；
           }
           {
           System.out.println("这是一段非静态初始化程序"）；
           }
        }
----------------------
public class StaticInitDemo{
      static int i=5;
      //静态初始化块
      static{
         System.out.println("Static code i= "+i++);
         }
       }
      public class Test{
           public static void main(String args[]){
           System.out.println("Main cod:i="+StaticInitDemo.i);
      }

-------------------------------------------------------
--------------------------------------------------------
final修饰的类不能被继承
final修饰的方法不能被覆盖，final保证方法有唯一的实现
final修饰的变量是常量
创建final类通常是出于安全的安全
（java.lang.String是一个final类）
final的方法不支持动态链编，所以运行的效率要高，但同时也失去了扩展性
如果一个实例的引用被标记为final,那么该引用不能指向任何其他对象。但可能改变对象的内容，因为只有引用本身是final的 。
public class A{
int i=10;
}
public class B{
  public void method(){
     final A test =new A();
     test.i=100;//这样不会出错，改变a的内容是容许的
     //test=new B();这行代码会出错
   }
}

----------------------------------------
-----------------------------------------
instanceof运算符，它可以判断一个对象是否是某个类，返回boolean值。
使用方法是“对象a instanceof 类A”，是返回true
public class Employee
public class Manager extends Employee
public class Contractor extentds Employee
public void method(){
       Employee e=new Employee();
   Manager m=new Manager();
   Contractor c=new Contractor();
   boolean b1=e instanceof Manager;//false
        boolean b2=e instanceof Employee;//true
  boolean b3=m instanceof Employee;//true
  boolean b4=m instanceof Contractor;//false
  }
}
-----------------------------------------------------
-----------------------------------------------------
String和StringBuffer

java.lang.String类用来表示字符串
String对象的特点是一旦将其内容就不会被改变
String a=new String("I love");//使用new创建一个String对象
a=a+"  Java"//在a后面附加上“java”

java.lang.StringBuffer类提供了可字符串=n的方法
StringBuffer对象的内容是可改变的
StringBuffer sb=new StringBuffer("I love");//创建了一个StringBuffer对象
sb=sb.append("java");//在后面附加了“java”

由于String的不变性，所以频繁的改变String的内容会生成大量的对象，造成一定的性能问题。
public class test{
public String mehtod1（String s){
    String A="hello ";
    for(int i=0;i<100;i++);
    A=A+s;
    return a;
}

public String method2(String s){
  StringBuffer sb=new StringBuffer("hello");
  StringBuffer sb2=new StringBuffer("s");
  for(int i=0;i<100;i++){
     sb=sb.append(sb2);
  }
  return sb.toString();
}
}//method1和method2进行的操作是安全一样的，但性能差别很大，method2的方法比method1好很多

String的常用方法
concat方法 连接字符串
lastIndexOf方法 返回参数在字符串中最好出现的位置
length方法 返回字符串的长度
replace方法 替换字符
trim方法 返回去掉开头和结尾的空格后的字符串
toLowerCase 转化为小写
toUpperCase 转化为大写
toCharArray 转换成字符的数组

StringBuffer的常用方法
append方法 附加字符串
lastIndexOf方法 返回参数在字符串中最后出现的位置
replace方法 替换字符
capacity方法 返回当前的StringBuffer的长度
insert方法 插入字符串
toString方法 转换成字符串

toString被用来将一个对象转换成String表达式。返回一个字符串用来表示对象的消息。
  Data now=new Date();
  System.out.println(now);//相当于 System.out.println(now.toString());

如果一个类没有提供toString方法，则默认调用Object的toString方法
  public String toString(){
       return getClass().getName()+"@"+Integer.tollexString(hashCode());
  }

------------------------------------------------------------------------------------------------------------------------------------------------
==运算符用来比较两个对象是否相等，即判断两个引用的内存地址是否相等
对于基本类型变量只要相等则a==b为true
对象间进行==运算的两者必须同一类产生的对象，或对象的类之间存在父子类关系。
class A{}
class b{}
public class test{
  public static void main(String args[]){
                A a=new A();
                B b=new B();
                boolean bo=a==b;//编译错误，因为a和b不是同一个类参数的对象
     }
}

------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
抽象类和接口的区别
接口可以被多重implements,抽象类只能被单一extends
接口只有定义，抽象类可以有定义和实现
接口的字段定义默认为:public static final,抽象类字段默认“friendly”

Hashtable的原理，HashMap与Hashtable的区别
Hashtable的原理：通过节点的关键码确定节点的存储位置，即给定节点的关键码k，通过一定的函数关系H（散列函数），得到函数H（k)，将此值解释为该节点的存储地址，HashMap与Hashtable很相似，但HashMap是非同步的（unsynchronizded)和可以以null为关键码。

-----------------------------------------------------------------------------
JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。 　　Java反射机制主要提供了以下功能： 在运行时判断任意一个对象所属的类；在运行时构造任意一个类的对象；在运行时判断任意一个类所具有的成员变量和方法；在运行时调用任意一个对象的方法；生成动态代理。
一个Class代表一分字节码，一个Method代表这个字节码里面的一个方法，一个Constructor就代表这个字节码里面的一个构造方法(String.class.getConstructor(参数).Field类代表某个类中的成员变量

（Field Method COntructor Package）

反射专题：
什么是动态语言：就是程序运行时，容许改变程序结构或变量类型的语言
java不是这样的语言，但他却有有着一个非常出色的动态相关机制：那就是反射（Relection).
反射：主要是指程序可以访问、检测和修改他本身状态或行为的一种能力
java反射机制是在运行状态中，对于任意一个类，都能知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法。每一个类都有一个Class对象。即每当编译一个新类，就会产生一个Class对象。Class没有公告构造方法。Class对象是在加载类时由java虚拟机以及通过调用类加载器中的defineClass方法自动构造的，故不能显示地声明一个Class对象

实例化无参构造函数的对象，两种方式：Class.newInstance();
 Class.getConstructor(new Class[]{}).newInstance(new Object[]{})

实例化带参数的构造函数的对象：
class.getConstructor(Class<?>...parameterTypes).newInstance(Object...initargs)

javaBean:满足某种特定规则（get set)的类，（一个普通的类可以当做javabean也可不当做javabean来用）
JavaBean的内省就是对JavaBean中的属性和事件的一些处理方法，通过setName和getName去访问和设置name的值。

1、Java中通过Introspector类的getBeanInfo(beanClass)静态方法，获得JavaBean的BeanInfo集合，再遍历BeanInfo集合来得到JavaBean的某一个属性的属性描述器（PropertyDescriptor），利用PropertyDescriptor得到JavaBean中属性的get和set方法。

  BeanInfo beanInfo = Introspector.getBeanInfo(Point.class);
  PropertyDescriptor[] pds = beanInfo.getPropertyDescriptors();
  for(PropertyDescriptor pd1:pds){
   if(pd1.getName().equals("y")){
    Method method3 = pd1.getReadMethod();
    System.out.println(method3.invoke(p1));
    Method method4 = pd1.getWriteMethod();
    method4.invoke(p1, 5);
    System.out.println(method3.invoke(p1));
    System.out.println(pd1.getName());
   }
  }

2。、或者直接通过新建一个JavaBean属性的PropertyDescriptor来得到该属性的get和set方法。

  String propertyName = "x";
  Point p1 = new Point(1,2);
  PropertyDescriptor pd = new PropertyDescriptor(propertyName,Point.class);
  Method method1 = pd.getReadMethod();
  System.out.println(method1.invoke(p1));
  Method method2 = pd.getWriteMethod();
  method2.invoke(p1, 4);
  System.out.println(method1.invoke(p1));
--------------------------------------------------------------------------
泛型是给编译器看的
只有引用类型才能作为泛型的参数
参数化类型不考虑继承
public class FanXing{
public static void main(String args[]){
String x1=autoConvert(obj):
}

private static<T>T autoConvert(object obj){
return(T) obj;

}
private static <T> fillArray(T[] a,T obj){
for(int i=0;i<a.length;i++){
a[i]=obj;
}
}

}