黑马程序员_高新技术部分知识点

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

 

零散知识点：

1、Eclipse与MyEclipse的区别：MyEclipse是Eclipse的插件(补丁)——用Java开发出来的               

2、Eclipse是IDE(集成开发环境)的开发工具

3、(简写：Java ee    jde—integrity development environment  Jms   jmx   jndi)

4、IDE开发工具都支持使用project工程化的方式管理一个项目的程序开发过程.(一个项目就是一个工程)；资源文件就是配置文件——(工作间与工程的关系：一个工作间包括多个工程，一个工作间的设置影响所有工程)

5、在Myeclipse中Window的Preferences(首选项)；

6、开发有2个阶段：编译时阶段(开发阶段Preferences—java—Compiler)、运行时阶段Preferences—java—Installed JREs

7、切换工作间：File—Switch WorkSpace；新建一个工程：File—Java project; 

8、perspective(透视图)与view(视图)：——不同的透视图就是有若干个小窗口(视图)的集合

(切换透视图即可得到相应窗体)

在eclipse里面如何日调试：点击单点，然后debug调试运行，选中变量点右键Watch(观察)—就可以看见结果

显示窗口：window—Show View里面，如果没有找到则进入里面的Other查找

9、包名：cn.itcast  (域名.名)  修改工程名字：工程名右键—Refactor—Rename

10、设置快捷键window—Preferences—General—Keys—敲写content a(内容助理)，也可以查找是否有重复快捷键功能

11、高版本的java能运行低版本的javac编译的程序，反之则不行

 

静态导入

Ipmort语句可以导入一个类或者某个包中的所有的类。
package cn.itcast.day1;

import staticjava.lang.Math.max;

import staticjava.lang.Math.*;

public classStaticImport {

         public static void main(String[] arr){

                   int x = 1;

                   x++;

                   System.out.println(x);//syso

                   System.out.println(max(3,6));

                   System.out.println(abs(3 -6));        

         }

}

 

可变参数以及Overload(重载) 与override(重写)的区别

重载Overload：在同一个类中可以存在一个以上的同名函数，只要他们的参数个数或参数类型不同即可

重写override：当子类出现和父类一样的函数时，当子类对象调用该函数会运行子类函数内容，如同父类函数被覆盖

public staticint add(int x ,int ...args){

         int sum = x;

                   for(int i=0;i<args.length;i++){

                            sum+=args[i]; 

                   }

                   return sum;

可变参数的特点：

(1)只能出现在参数列表的最后

(2)位于变量类型和变量名之间，前后有无空格都可以

(3)调用时，编译器为该可变参数隐含创建一个数组，在方法体中以数组的形式访问可变参数

 

高级for循环

for(type 变量名：集合变量名){…}                         //注释：Ctrl+Shift+/

         public static int add(int x ,int...args){

                   int sum = x;

                   for(int arg : args){

                            sum +=arg;

                   }

                   return sum;

         }

 

基本数据类型的自动拆箱与装箱

注意：对于基本类型的整数装箱成Integer对象在一个字节之内(-128-127)，就会被缓存起来节省内存空间

这就是一个模式：享元模式flyweight：如WORD里面就可能会用到(英文字母)或者桌面图标等

packagecn.itcast.day1;

 

importjava.lang.reflect.Constructor;

importjava.lang.reflect.Field;

importjava.lang.reflect.Method;

 

public classReflectTest {

         public static void main(String[]args)throws Exception {

         String str1 ="abc";

         Class cls1 = str1.getClass();

         Class cls2 = String.class;

         Class cls3 =Class.forName("java.lang.String");//抛异常

         System.out.println(cls1 == cls2);                    //true

         System.out.println(cls1 == cls3);                                            //true

        

         System.out.println(cls1.isPrimitive());//是否是原始类型 //false

         System.out.println(int.class.isPrimitive());                         //true

         System.out.println(int.class==Integer.class);                        //false

         System.out.println(int.class==Integer.TYPE);                            //true

         System.out.println(int[].class.isPrimitive());                      //false

         System.out.println(int[].class.isArray());                                     //true

 

枚举

枚举就是让某个类型的变量的取值只能为若干个固定值中的一个，否则编译就会报错

用类来模拟枚举的功能：

(1)私有的构造函数(2)每个元素分别用一个共有的静态成员变量来标示(3)可以有若干公有方法或抽象方法

注意：枚举只有一个成员时，就可以作为一种单例的实现方式。

package com.itheima.day01;

public enumWeekDay {

SUN(1),MON(),TUE,WED,TUR,FRI,SAT;//除了SUN外，其余调用的构造方法都是(1)

PrivateWeekDay(){};                             //(1)构造方法必须在列表之后

PrivateWeekDay(int day){};                //(2)

}

注意：最后一个枚举元素后面可以加分号，也可以不加分号。!!!

//需求制作一个简单的交通灯外加时间限制

public enum TrafficLamp{

                   RED(30){

                            publicTrafficLamp nextLamp() {

                                     returnGREEN;

                            }

                   },//子类必须完成父类的抽象方法

                   GREEN(45){

                            publicTrafficLamp nextLamp() {

                                     returnTELLOW;

                            }

                   },

                   TELLOW(5){

                            publicTrafficLamp nextLamp() {

                                     returnRED;

                            }

                   };//RED是TrafficLamp子类的实例对象

                   publicabstract TrafficLamp nextLamp();

                   privateint time;

                   privateTrafficLamp(int time){this.time = time;}     

         }

 

反射：(没理解透彻,需重新复习) 

反射就是把Java类中的各种成分映射成相应的java类。

构造方法的反射：

onstructor类代表某个类中的一个构造方法；

得到某个类所有的构造方法：

Constructor []constructors=Class.forName("java.lang.String").getConstructors();

得到某一个构造方法：(获得方法时要用到类型)

Constructor constructor=Class.forName(“java.lang.String”).getConstructor(StringBuffer.class);

创建实例对象：(调用获得的方法时要用到上面相同类型的实例对象)

通常方式：Stringstr = newString(new StringBuffer("abc"));

反射方式： Stringstr =(String)constructor.newInstance(new StringBuffer("abc"));

Class.newInstance()方法：

String obj=(String)Class.forName("java.lang.String").newInstance();

该方法内部先得到默认的构造方法，然后用该构造方法创建实例对象。也就是使用String类的无参构造 

方法创建了一个String对象。

 

成员方法的反射（Method）：

Method类代表某个类中的一个成员方法。

得到类中的某一个方法： 

Method charAt=Class.forName("java.lang.String").getMethod("charAt",int.class);

调用方法：

通常方式：System.out.println(str.charAt(1));

反射方式： System.out.println(charAt.invoke(str,1));

如果传递给Method对象的invoke()方法的第一个参数为null，说明该Method对象对应的是一个静态方法！

 

数组的反射：

1、具有相同维数和元素类型的数组属于同一个类型，即具有相同的Class实例对象。

2、代表数组的Class实例对象的getSuperClass()方法返回的父类为Object类对应的Class。

3、基本类型的一维数组可以被当作Object类型使用，不能当作Object[]类型使用；非基本类型的一维数组，既可以当做Object类型使用，又可以当做Object[]类型使用。

无法通过反射直接获得数组中元素的类型，但可以通过其中一个元素获得类型： a[0].getClass().getName();

 

泛型的反射：

通过反射获取方法，再获得方法的参数列表的类型，获取其参数的实际类型。

 

ArrayList_HashSet的比较及Hashcode分析

结果4；改成结果3；

问HashCode()的作用：如果2个对象的equals()相等的话，那么他们的HashCode()也应该相等，如果对象不存储到哈希集合中，就不要弄hashCode()；同时当一个对象存储进hashCode()集合中，就不能修改这个对象中的那些参与哈希值得字段了，可以防止内存泄露。

问Java中有内存泄露：有；原因：对象不用了但却占用内存空间不被释放；举例说明如上。

 

JavaBean

JavaBean是一种特殊的Java类，主要用于传递数据信息，这种java类中的方法主要用于访问私有的字段，且方法名符合某种命名规则。

如果要在两个模块之间传递多个信息，可以将这些信息封装到一个JavaBean中，这种JavaBean的实例对象通常称之为值对象（Value Object，简称VO）。这些信息在类中用私有字段来存储，如果读取或设置这些字段的值，则需要通过一些相应的方法来访问，JavaBean的属性是根据其中的setter和getter方法来确定的，而不是根据其中的成员变量。

setId()的属性名-->id

isLast()的属性名-->last

setCPU的属性名是什么?-->CPU

getUPS的属性名是什么？-->UPS

总之，一个类被当作javaBean使用时，JavaBean的属性是根据方法名推断出来的，它根本看不到java类内部的成员变量。

一个符合JavaBean特点的类可以当作普通类一样进行使用，但把它当JavaBean用肯定需要带来一些额外的好处

(1)在Java EE开发中，经常要使用到JavaBean。很多环境就要求按JavaBean方式进行操作

(2)JDK中提供了对JavaBean进行操作的一些API，这套API就称为内省。如果要你自己去通过getX方法来访问私有的x，怎么做，有一定难度吧？用内省这套api操作JavaBean比用普通类的方式更方便。

 

Public class ReflectPoint{

         privateint x;

         publicint y;

         publicReflectPoint(int x,int y){

         super();

this.x = x;

this.y = y;

}

}

public static void main(String[]args){

ReflectPointpt1 = new ReflectPoint(3,5);

StringpropertyName = “x”;

//”x”——“X”——“getX”——MethidGetX

propertyDescriptorpd = new propertyDescriptor(propertyName,pt1.getClass());

MethidMethidGetX = pb.getReadMethod();

Object retVal= methidGetX.invoke(pt1);

System.out.println(retVal);

}

 

内省综合案例

用eclipse自动生成 ReflectPoint类的setter和getter方法。

直接new一个PropertyDescriptor对象的方式来让大家了解JavaBeanAPI的价值，先用一段代码读取JavaBean的属性，然后再用一段代码设置JavaBean的属性。

演示用eclipse将读取属性和设置属性的流水帐代码分别抽取成方法：

只要调用这个方法，并给这个方法传递了一个对象、属性名和设置值，它就能完成属性修改的功能。

得到BeanInfo最好采用“obj.getClass()”方式，而不要采用“类名.class”方式，这样程序更通用。

采用遍历BeanInfo的所有属性方式来查找和设置某个RefectPoint对象的x属性。在程序中把一个类当作JavaBean来看，就是调用IntroSpector.getBeanInfo方法，得到的BeanInfo对象封装了把这个类当作JavaBean看的结果信息。

 

注解(annotation)

JDK1.5以后新特性：注解和枚举(反射不是)

注解的作用：用于告诉工具软件，向他传达一种信息。

注解相当于一种标记，在程序中加了注解就等于为程序打上了某种标记，反之则没有。

标记可以加在包、类、字段、方法、方法参数、局部变量上以及构造方法中等。

通过java.lang包，可以看到JDK中提供的最基本的Annotation

注解的类型有三种Annotation Types：Deprecated  Override  SuppressWamings

注解的应用结构：@interfaceA{}                   //注解类

                               @Class B{}                            //应用了”注解类”的类

                               @Class C{ B.class.isAnnotationPresent(A.class);    

                                                   A  a= B.class.getAnnotation(A.class) }          //对应用了注解类的类进行反射操作的类

注意：在注解类中加上的注解也称之为元注解，即信息的信息也叫元信息

定义一个最简单的注解：public@interface MyAnnotation{}

把他加在某个类上：@MyAnnotation public class Annotation Test{}

用反射进行测试Annotation Test的定义上是否有@MyAnnotation

根据发射测试的问题，引出@Reteion元注解的讲解、其三种取值：

         @ReteionPolicy.CLASS、@ReteionPolicy.SOURCE、@ReteionPolicy.RUNTIME

分别对应java元文件—>class文件—>内存中的字节码

 

泛型：

JDK1.5版本以后出现新特性。用于解决安全问题，是一个类型安全机制。

泛型是提供给javac编译器使用的，可以限定集合中的输入类型，让编译器挡住源程序中的非法输入，编译器编译带类型说明的集合时会去除掉“类型”信息，使程序运行效率不受影响，对于参数化的泛型类型，getClass()方法的返回值和原始类型完全一样。 

整个称为ArrayList<E>泛型类型

ArrayList<E>中的E称为类型变量或类型参数

整个ArrayList<Integer>称为参数化的类型

ArrayList<Integer>中的Integer称为类型参数的实例或实际类型参数

ArrayList<Integer>中的<>念着typeof

ArrayList称为原始类型

参数化类型不考虑类型参数的继承关系，如下两种定义方法是错误的：

Vector<String>v = newVector<Object>();

Vector<Object>v = newVector<String>();

限定通配符的上下边界：

Vector<? ExtendsNumber >x = new Vector<Integer>();

Vector<?super Integer >x = new Vector< Number >();

 

优点：

1．将运行时期出现问题ClassCastException，转移到了编译时期。方便于程序员解决问题。让运行时问题减少，安全。

2．避免了强制转换麻烦。

泛型格式：通过<>来定义要操作的引用数据类型。

在使用java提供的对象时，什么时候使用泛型：通常在集合框架中很常见，只要见到<>就要定义泛型

其实<>就是用来接收类型的，当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可

 泛型类：

当类中要操作的引用数据类型不确定的时候，早期定义Object来完成扩展。现在定义泛型来完成扩展。

注意：静态方法不可以访问类上定义的泛型，如果静态方法操作的引用数据类型不确定可以将泛型定义在方法上原因是静态先加载后有对象。

总结：？ 通配符，也可以理解为占位符。

泛型的限定：？ extends E：可以接受E类型或者E的子类型。上限

                            ？ supper E：可以接受E类型或者E类型的父类型。下限  (泛型高级应用)

 

类加载器：

类加载器：简称加载类的工具(java类)

ava虚拟机中有多个，系统默认有三个加载器(BootStrap,ExtClassLoader,AppClassLoader)，每个类加载器负责加载不同位置的类注意：因为java类的类加载器本身也要被类加载器加载，所以必须有第一个类加载器。BootStrap

ClassLoaderTest.class.getClassLoader.getClass()———是java对象，有自己的名字的呢等 getName()——>AppClassLoader

System.class.getClassLoader();——> BootStrap

类加载器组成结构：BootStrap——>ExtClassLoader——>AppClassLoader——>MyClassLoader/ ItcastClassLoader

 

类加载器的委托机制：

使用java虚拟机加载类时，如何安排：

当前线程的类加载器去加载线程中的第一个类

如果类A中引用了类B，java虚拟机将使用加载类A的类装载器来加载类B

还可以直接调用ClassLoader.loadClass()方法来指定某个类加载器去加载某个类

 

自定义加载器的编写原理

(1)自定义的类加载器必须继承ClassLoader

(2)loadClass方法与findClass方法

(3)defineClass方法

(模板方法设计：模板方法：定义功能时，功能的一部分是确定的，有一部分是不确定的，确定的部分在使用不确定的部分，这时就将不确定的部分暴漏出去，由该类的子类去完成。)

 

class NetworkClassLoader extends ClassLoader{

       Stringhost;

Int port;

Public Class findClass(String name){

              Byte[] b = loadClassData(name);

Return defineClass(name,b,0,b,length);

}

Private byte[] loadClassData(String name){

              //load the class data form the connection 

…

}

}

 

类加载器的加密工具类

加密和解密都是同一个函数MyClassLoader

Private static void cipher(InputStreamips,OutputStream ops)throws Exception{

Int b= –1;

While((b=ips.read())!=-1){

ops.write(b ^ 0xff);

}

}

//现在要调用加密的类——传递给一个文件的路径和保存文件的路径

//传源和目标——主函数中(该类为加密类)

String srcPath= args[0];      String destDir= args[1];

FileInputStream sif = newFileInputStream(srcPath);

String destFileName = srcPath.subString(srcPath.lastIndexOf(‘\\’)+1);

String destPath = destDir +”\\”+destFileName;

FileOutputStream sif = new FileOutputStream(destPath);

cyher(fis,fos);

fis.close();

fos.close();

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