java 基础加强(myeclipse,debug,junit,JDK5新特性,反射)

思维导图

java 基础加强(myeclipse,debug,junit,JDK5新特性,反射)_第1张图片



 

1、myeclipse的安装和使用

       *eclipse:是一个免费的开发工具

       *myeclipse:是一个收费的插件,破解myeclipse,

              **安装目录的要求: 不能有中文和空格

              **安装完成之后,选择一个工作空间 ,这个工作空间不能有中文和空格

       *破解myeclipse

              **运行run.bat文件,但是运行之前,必须要安装jdk,通过配置环境变量

 

       *myeclipse的使用

              *创建一个工程

                     -类型 javaproject  web  project

                     -选择依赖的jdk,可以使用myeclipse自带的jdk,或者可以使用安装的jdk

             

              *创建包 package

                     -cn.itcast.test  XX.XX.XX

             

              *在包里面创建一个类

                     -类的命名规范:

                            **首字母要大写

                                   比如: TestDemo1  UserManager

             

              *在类里面创建方法

                     publicvoid test1(参数列表) {

                            方法体或者返回值;

                     }

                     -方法的命名规范

                            首字母小写  比如:addNum()

             

              *定义变量

                     -变量的命名规范

                     **首字母小写,第二个单词的首字母要大写 ,比如 userName

             

              *这些命名还有一种方式

                     **使用汉语拼音命名yonghuming mima

                     **不能把汉语拼音和英文字母混合使用

                            userMing

 

              *命名的最基本的原则:看到名字知道是什么含义

 

              *代码需要有缩进

 

              *运行程序  run as java application

                         debug as java application

 

2、debug的调试模式(断点调试模式)

       *使用这种模式,调试程序(看到程序里面数据的变化)

 

       *使用debug第一步需要设置一个断点(让程序运行停止在这一行)

              -显示出来行号

              -双击左边,出现一个圆点,表示设置了一个断点

       *使用debug as方式,运行程序

              -提示是否进入到调试界面,yes

              -在断点那一个,有一个绿色条,表示程序停止在这一行,没有向下运行

 

       *可以让程序向下执行,

              -使用 step over 快捷键是 F6(单步执行)

              -resume F8:表示调试结束,直接向下运行

                     **比如当前的断点之后还有断点,跳到下一个断点,

                     ** 如果当前断点后面没有断点,程序直接运行结束

      

       *debug另外一个用途

              **查看程序的源代码

              **F5 step into:进入到方法

              **F7 step return :返回

 

3、myeclipse的快捷键的使用

       *代码提示 alt /

       *快速导包 ctrlshift o

       *单行注释 ctrl /

       *去掉单行注释 ctrl /

       *多行注释 ctrl shift/

       *去掉多行注释 ctrlshift \

       *删除行 ctrl d

 

4、junit的使用

       *单元测试

 

       *测试对象是 是一个类中的方法

 

       *juint不是javase的一部分,想要使用导入jar包

              **但是,在myeclipse中自带了junit的jar包

      

       *首先junit版本 3.x 4.x

              *单元测试方法时候,方法命名规则 public void 方法名() {}

      

       *使用注解方式运行测试方法, 在方法的上面

              **@Test:表示方法进行单元测试

 

              ---     @Test

                     publicvoid testAdd1() {

                            TestJunittest01 = new TestJunit();

                            test01.testAdd(2,3);

                     }

                     -选中方法名称,右键运行 点击run as --- junit  test

                     -当出现绿色条,表示方法测试通过

                     -当出现了红棕色条,表示方法测试不通过

 

              ---要运行类中的多个测试方法,点击类中的其他位置,run as --- junit  test

      

              **@Ignore :表示这个方法不进行单元测试

 

              **@Before: 在每个方法执行运行

              **@After:在每个方法之后运行

 

              **断言(了解)

                     -Assert.assertEquals("测试期望的值", "方法运行的实际的值")

             

jdk5.0新特性

jdk 1.1 1.2   1.4   5.0

** 泛型、枚举、静态导入、自动拆装箱、增强for、可变参数

** 反射

 
5、泛型的简介

       *为什么要使用泛型?

              -一般使用在集合上

              **比如现在把一个字符串类型的值放入到集合里面,这个时候,这个值放入到集合之后,失去本事的类型,只能是object类型,

              这个时候,比如想要对这个值进行类型转换,很容易出现类型转换错误,怎么解决这个问题,可以使用泛型来解决

      

       *在集合上如何使用泛型

              -常用集合 list  set map

              -泛型语法 集合  比如 List

       *在泛型里面写是一个对象,String不能写基本的数据类型 比如int (****)

              **写基本的数据类型对应包装类

                     byte-- Byte

                     short-- Short

 

                     int-- Integer

 

                     long-- Long

 

                     float-- Float

                     double-- Double

 

                     char   -- Character

 

                     boolean-- Boolean

 

       *在list上使用泛型

              list的三种实现 ArrayList linkedList  Vector

              代码:

              @Test

              publicvoid testList() {

                     Listlist = new ArrayList();

                     list.add("aaa");

                     list.add("bbb");

                     list.add("ccc");

 

                     //遍历list集合有几种方式  三种

                     //普通for循环  迭代器 增强for

 

                     //普通for循环

                     for(inti=0;i

                            Strings = list.get(i);

                            System.out.println(s);

                     }

 

                     System.out.println("=================");

                     //使用增强for

                     for(String s1 : list) {

                            System.out.println(s1);

                     }

 

                     System.out.println("=================");

                     //使用迭代器遍历

                     Iteratorit = list.iterator();

                     while(it.hasNext()){

                            System.out.println(it.next());

                     }

 

              *作业1: ArrayList linkedList  Vector 这三个区别

 

       *在set上使用泛型

              代码:

              //泛型使用set集合上

              @Test

              publicvoid testSet() {

                     Setset = new HashSet();

                     set.add("www");

                     set.add("qqq");

                     set.add("zzz");

                     //set.add("qqq");

                     //遍历set 有几种方式  两种

                     //迭代器 增强for

                     //使用增强for遍历

                     for(String s2 : set) {

                            System.out.println(s2);

                     }

                     System.out.println("=================");

                     //使用迭代器遍历

                     Iteratorit1 = set.iterator();

                     while(it1.hasNext()){

                            System.out.println(it1.next());

                     }

              }

      

       *在map上面使用泛型

              -map结构:key-valu形式

              代码:

              //在map上使用泛型

              @Test

              publicvoid testMap() {

                     Mapmap = new HashMap();

                     map.put("aaa","111");

                     map.put("bbb","222");

                     map.put("ccc","333");

                     //遍历map 有几种遍历方式两种

                     //1、获取所有的key,通过key得到value 使用get方法

                     //2、获取key和value的关系

                     //使用第一种方式遍历

                     //获取所有的key

                     Setsets = map.keySet();

                     //遍历所有key返回的set

                     for(String key : sets) {

                            //通过key得到value

                            Stringvalue = map.get(key);

                            System.out.println(key+": "+value);

                     }

                    

                     System.out.println("==============");

                     //得到key和value的关系

                     Set> sets1 = map.entrySet();

                     //遍历sets1

                     for(Entry entry : sets1) {

                            //entry是key和value关系

                            Stringkeyv = entry.getKey();

                            Stringvaluev = entry.getValue();

                            System.out.println(keyv+": "+valuev);

                     }

              }

 
6、泛型使用在方法上

       *定义一个数组,实现指定位置上数组元素的交换

       *方法逻辑相同,只是数据类型不同,这个时候使用泛型方法

       */*

        * 使用泛型方法需要定义一个类型 使用大写字母表示 T :这个T表示任意的类型

        * 写在返回值之前  void之前

        * =======表示定义了一个类型这个类型是 T

        * 在下面就可以使用这个类型了  T

        * */

      

       publicstatic void swap1(T[] arr ,int a,int b) {

              Ttemp = arr[a];

              arr[a]= arr[b];

              arr[b]= temp;

       }

 

       **作业2: 实现一个泛型方法,接受任意一个数组,颠倒数组中所有元素

 

7、泛型在类上的使用(了解)

       *在一个类上定义一个类型,这个类型可以在类里面直接使用

       *public class TestDemo04 {

      

       //在类里面可以直接使用T的类型

       Taa;

       publicvoid test11(T bb) {}

      

       //写一个静态方法 在类上面定义的泛型,不能再静态方法里面使用

       publicstatic void test12(A cc) {}

       }

 
8、枚举的简介

       *什么是枚举?

              **需要在一定的范围内取值,这个值只能是这个范围内中的任意一个。

              **现实场景:交通信号灯,有三种颜色,但是每次只能亮三种颜色里面的任意一个

      

       *使用一个关键字 enum

       **enum Color3 {

              RED,GREEN,YELLOW;

       }

       *枚举的构造方法也是私有的

 

       *特殊枚举的操作(了解)

       **在枚举类里面有构造方法

              **构造方法里面有参数,需要在每个实例上面都写参数

       **在枚举类里面有抽象方法

              **在枚举的每个实例里面都重写这个抽象方法

 
9、枚举的api的操作

       **name() :返回枚举的名称

       **ordinal() :枚举的下标,下标从0开始

       **valueOf(Class enumType, String name) :得到枚举的对象

 

       **还有两个方法,都是这两个方法不在api里面,编译的时候生成两个方法

       ***valueof(String name)  转换枚举对象

       ***values()  获得所有枚举对象数组

 

       *练习:枚举对象、枚举对象下标、枚举对象名称表示之间的转换

       -//知道枚举的对象,得到枚举名称和下标

       @Test

       publicvoid test1() {

              //得到枚举对象

              Color100c100 = Color100.RED;

              //枚举名称

              Stringname = c100.name();

              //枚举的下标

              intidx = c100.ordinal();

              System.out.println(name+""+idx);

       }

 

       -//知道枚举的名称,得到枚举的对象和下标

       @Test

       publicvoid test2() {

              Stringname1 = "GREEN";

              //得到对象

              Color100c1 = Color100.valueOf(name1);

              //枚举下标

              intidx1 = c1.ordinal();

              System.out.println(idx1);

       }

 

       -//知道枚举的下标,得到枚举的对象和名称

       @Test

       publicvoid test3() {

              intidx2 = 2;

              //得到枚举的对象

              Color100[]cs = Color100.values();

              //根据下标得到对象

              Color100c12 = cs[idx2];

              //得到枚举的名称

              Stringname = c12.name();

              System.out.println(name);

       }

 
10、静态导入(了解)

       *可以在代码里面,直接使用静态导入方式,导入静态方法或者常量

       *import static XX.XX.xxx

 

       *import static java.lang.System.out;

       importstatic java.util.Arrays.sort;

 

       **比如现在实现一个计算器 在Math类里面

 
11、自动拆装箱

       *装箱

              **把基本的数据类型转换成包装类

       *拆箱

              **把包装类转换成基本的数据类型

 

       **  //自动装箱

              Integeri = 10;

             

              //自动拆箱

              intm = i;

      

       **在jdk1.4里面如何实现装箱和拆箱

              -//在jdk1.4里面实现拆装箱

              publicvoid test1() {

                     //装箱

                     Integerm = new Integer(10);       

                     //拆箱    

                     inta = m.intValue();

              }

       **jdk是会向下兼容

              -比如 jdk1.4里面写的代码,这个时候到5.0里面也可以运行

 

       **练习:向下兼容

       ==执行的结果是会调用  doSomething(double m)

       ==首先在jdk1.4里面肯定调用这个方法,如果调用下面的方法,需要类型转换,但是jdk1.4不能实现自动拆装箱

       ==由于jdk是向下兼容,所以,在jdk1.4调用这个方法,在jdk5.0里面还是会调用这个方法

              publicstatic void main(String[] args) {

                     doSomething(10);

 

              }

             

              publicstatic void doSomething(double m) {

                     System.out.println("double......");

              }

             

              publicstatic void doSomething(Integer a){

                     System.out.println("integer.....");

              }

       **记住:八种基本的数据类型对应的包装类

              *int --- Integer

              *char--- Character

 
12、增强for循环(*****)

       *语法 for(遍历出来的值 : 要遍历的集合) {}

              -for(String s : list) {

                     System.out.println(s);

              }

       *使用场景: 数组;实现Iterable接口的集合 可以使用增强for循环

 

       *在集合上使用增强for循环遍历

              list  set 实现了Iterator接口,所以可以使用增强for循环

              map不能使用增强for循环,没有实现Iterator接口,所以不能使用增强for循环

 

       *增强for循环出现目的:为了替代迭代器

              **增强for底层就是迭代器实现的

      

13、内容补充

       (1)泛型擦除

              *首先泛型只是出现在源代码阶段,当编译之后泛型不存在了

      

       (2)练习:实现一个泛型方法,接受任意类型的数组,颠倒数组中所有元素

       代码

       publicstatic void reverses(T[] arr1) {

              /*

               * 基本思想:把第一个元素和最后一个元素交换位置,把第二个元素和倒数第二个元素交换位置。。。。

               * 交换长度/2

               * */

              //遍历数组

              for(inti=0;i

                     /*inttemp = arr1[0];

                     arr1[0]= arr1[arr1.length-1];*/

                     Ttemp = arr1[i];

                     arr1[i]= arr1[arr1.length-i-1];

                     arr1[arr1.length-i-1]= temp;

              }

             

       }

 

14、可变参数

       *可变参数可以应用在什么场景:

       **实现两个数的相加,实现三个数的相加 四个数的相加

       --如果实现的多个方法,这些方法里面逻辑基本相同,唯一不同的是传递的参数的个数,可以使用可变参数

 

       *可变参数的定义方法 数据类型...数组的名称

       *理解为一个数组,这个数组存储传递过来的参数

       -代码

              publicstatic void add1(int...nums) {

                     //nums理解为一个数组,这个数组存储传递过来的参数

                     //System.out.println(nums.length);

                     intsum = 0;

                     //遍历数组

                     for(inti=0;i

                            sum+= nums[i];

                     }

                     System.out.println(sum);

              }

      

       *注意的地方

              (1)可变参数需要写在方法的参数列表中,不能单独定义

              (2)在方法的参数列表中只能有一个可变参数

              (3)方法的参数列表中的可变参数,必须放在参数最后

                     -add1(int a,int...nums)

 

15、反射的原理(********理解********)

    java 基础加强(myeclipse,debug,junit,JDK5新特性,反射)_第2张图片   

*应用在一些通用性比较高的代码 中

       *后面学到的框架,大多数都是使用反射来实现的

 

       *在框架开发中,都是基于配置文件开发

              **在配置文件中配置了类,可以通过反射得到类中的 所有内容,可以让类中的某个方法来执行

 

       *类中的所有内容:属性、没有参数的构造方法、有参数的构造方法、普通方法

      

       *画图分析反射的原理

              *首先需要把java文件保存到本地硬盘 .java

              *编译java文件,成.class文件

              *使用jvm,把class文件通过类加载加载到内存中

              *万事万物都是对象,class文件在内存中使用Class类表示

 

              *当使用反射时候,首先需要获取到Class类,得到了这个类之后,就可以得到class文件里面的所有内容

                     -包含属性  构造方法普通方法

              *属性通过一个类 Filed

              *构造方法通过一个类Constructor

              *普通方法通过一个类Method

 

16、使用反射操作类里面的无参数的构造方法(**会写**)

       *首先获取到Class类

              -// 获取Class类

              Classclazz1 = Person.class;

              Classclazz2 = new Person().getClass();

              Classclazz3 = Class.forName("cn.itcast.test09.Person");

 

       *比如: 要对一个类进行实例化,可以new,不使用new,怎么获取?

              -//得到Class

              Classc3 = Class.forName("cn.itcast.test09.Person");

              //得到Person类的实例

              Personp = (Person) c3.newInstance();

       *代码

       //操作无参数的构造方法

       @Test

       publicvoid test1() throws Exception {

              //得到Class

              Classc3 = Class.forName("cn.itcast.test09.Person");

              //得到Person类的实例

              Personp = (Person) c3.newInstance();

              //设置值

              p.setName("zhangsan");

              System.out.println(p.getName());

       }

 

17、使用反射操作有参数的构造方法(**会写**)

       //操作有参数的构造方法

       @Test

       publicvoid test2() throws Exception {

              //得到Class

              Classc1 = Class.forName("cn.itcast.test09.Person");

              //使用有参数的构造方法

              //c1.getConstructors();//获取所有的构造方法

              //传递是有参数的构造方法里面参数类型,类型使用class形式传递

              Constructorcs = c1.getConstructor(String.class,String.class);

              //通过有参数的构造方法设置值

              //通过有参数的构造方法创建Person实例

              Personp1 = (Person) cs.newInstance("lisi","100");

              System.out.println(p1.getId()+""+p1.getName());

       }

 

18、使用反射操作属性(**会写**)

       *//操作name属性

       @Test

       publicvoid test3() {

              try{

                     //得到Class类

                     Classc2 = Class.forName("cn.itcast.test09.Person");

                     //得到name属性

                     //c2.getDeclaredFields();//表示得到所有的属性

                     //得到Person类的实例

                     Personp11 = (Person) c2.newInstance();

                     //通过这个方法得到属性,参数是属性的名称

                     Fieldf1 = c2.getDeclaredField("name");

                     //操作的是私有的属性,不让操作,需要设置可以操作私有属性setAccessible(true),可以操作私有属性

                     f1.setAccessible(true);

                     //设置name值 set方法,两个参数:第一个参数类的实例,第二个参数是设置的值

                     f1.set(p11,"wangwu"); //相当于 在 p.name = "wangwu";

                     System.out.println(f1.get(p11));//相当于 p.name

              }catch(Exceptione) {

                     e.printStackTrace();

              }

       }

 
19、使用泛型操作普通方法(**会写**)

       *使用Method类表示普通方法

       *代码

       //操作普通方法 ,比如操作 setName

       @Test

       publicvoid test4() throws Exception {

              //得到Class类

              Classc4 = Class.forName("cn.itcast.test09.Person");

              //得到Person实例

              Personp4 = (Person) c4.newInstance();

              //得到普通方法

              //c4.getDeclaredMethods();//得到所有的普通方法

              //传递两个参数:第一个参数,方法名称;第二个参数,方法里面参数的类型

              Methodm1 = c4.getDeclaredMethod("setName", String.class);

              //让setName方法执行 ,执行设置值

              //使用invoke(p4, "niuqi");传递两个参数:第一个参数,person实例;第二个参数,设置的值

              //执行了invoke方法之后,相当于,执行了setName方法,同时通过这个方法设置了一个值是niuqi

              m1.invoke(p4,"niuqi");

              System.out.println(p4.getName());

       }

      

       *//操作的私有的方法 ,需要设置值是true

       *//m1.setAccessible(true);

 

       *当操作的方法是静态的方法时候,因为静态方法调用方式是 类名.方法名,不需要类的实例

       *使用反射操作静态方式时候,也是不需要实例

       *在invokie方法的第一个参数里面,写一个 null

              -m1.invoke(null, "niuqi");

 


你可能感兴趣的:(java 基础加强(myeclipse,debug,junit,JDK5新特性,反射))