JAVA 基础加强学习笔记

一、面向对象

（一）继承 

1.继承的好处： 

(1) 提高了代码的复用性。 

(2) 让类与类之间产生了关系，提供了另一个特征多态的前提。  

注意： 子类中所有的构造函数都会默认访问父类中的空参数的构造函数，因为每一个子类构造内第一行都有默认的语句super();  如果父类中没有空参数的构造函数，那么子类的构造函数内，必须通过super语句指定要访问的父类中的构造函数。 如果子类构造函数中用this来指定调用子类自己的构造函数，那么被调用的构造函数也一样会访问父类中的构造函数。 

2.final特点： 

(1) 这个关键字是一个修饰符，可以修饰类，方法，变量。 

(2) 被final修饰的类是一个最终类，不可以被继承。 

(3) 被final修饰的方法是一个最终方法，不可以被覆盖。 

(4) 被final修饰的变量是一个常量，只能赋值一次。  

3.抽象类的特点： 

(1) 抽象方法只能定义在抽象类中，抽象类和抽象方法必须由abstract关键字修饰（可以描述类和方法，不可以描述变量）。 

(2) 抽象方法只定义方法声明，并不定义方法实现。 

(3) 抽象类不可以被创建对象(实例化)。 

(4) 只有通过子类继承抽象类并覆盖了抽象类中的所有抽象方法后，该子类才可以实例化。否则，该子类还是一个抽象类。 

(5)，抽象类只能单继承。 

4.抽象类的细节： 

(1) 抽象类中是否有构造函数？有，用于给子类对象进行初始化。 

(2) 抽象类中是否可以定义非抽象方法？ 可以。其实，抽象类和一般类没有太大的区别，都是在描述事物，只不过抽象类在描述事物时，有些功能不具体。所以抽象类和一般类在定义上，都是需要定义属性和行为的。只不过，比一般类多了一个抽象函数。而且比一般类少了一个创建对象的部分。 

(3) 抽象关键字abstract和哪些不可以共存？final , private , static  

(4) 抽象类中可不可以不定义抽象方法？可以。抽象方法目的仅仅为了不让该类创建对象。    

5.接 口：

  如果一个抽象类中的所有方法都是抽象的，且这个抽象类中的数据成员都是final的常量，那么，这个抽象类实际上就是一个接口，即一种特殊的抽象类。对于实现该接口的子类来说，接口不提供任何实现，接口是抽象方法和常量值定义的集合。

接口具有以下特点：

(1) 接口中的常量默认为public static final，而且也只能是public static final

(2) 接口中只能定义抽象方法，这些方法默认为public abstract，而且也只能是public abstract

(3) 接口可以继承其他接口，而且可以添加新的属性和抽象方法

(4) 在接口中声明方法时不能使用static、final、private等修饰符

(5) Java不允许类的多继承，但允许接口的多继承

(6) 不允许创建接口的实例，但允许定义接口类型的引用变量，改变量要引用实现了该接口的类的实例

(7) 一个类只能继承另外一个类，但能同时实现多个接口，并且重写方法必须显示声明为public 

抽象类和接口的区别：

(1) 抽象类只能被继承，而且只能单继承。 接口需要被实现，而且可以多实现。  

(2) 抽象类中可以定义非抽象方法，子类可以直接继承使用。 接口中的方法都是抽象方法，需要子类去实现。 

(3) 抽象类使用的是  is a 关系。 接口使用的 like a 关系。  

(4) 抽象类的成员修饰符可以自定义。 

接口中的成员修饰符是固定的。全都是public的。

（二）多 态

多态是面向对象特征之一，构造函数本身就具备多态性，某一种事物有不同的具体的体现。 体现：父类引用或者接口的引用指向了自己的子类对象。

//Animal a = new Cat(); 

多态的好处：提高了程序的扩展性。 

多态的弊端：当父类引用指向子类对象时，虽然提高了扩展性，但是只能访问父类中具备的方法，不可以访问子类中特有的方法。(前期不能使用后期产生的功能，即访问的局限性) 

多态的前提： 

1：必须要有关系，比如继承、或者实现。 

2：通常会有覆盖操作。  

（三）匿名内部类

匿名内部类是没有名字的内部类。就是内部类的简化形式。一般只用一次就可以用

这种形式。匿名内部类其实就是一个匿名子类对象。想要定义匿名内部类：需要前提，内部类必须继承一个类或者实现接口。 

匿名内部类的格式：new 父类名&接口名(){ 定义子类成员或者覆盖父类方法 }.方法。 

匿名内部类的使用场景：

 当函数的参数是接口类型引用时，如果接口中的方法不超过3个。可以通过匿名内部类来完成参数的传递。 其实就是在创建匿名内部类时，该类中的封装的方法不要过多，最好两个或者两个以内。 

二、多线程 

线程的两种创建方式

（一）创建线程的第一种方式：

继承Thread ，由子类复写run方法。 

步骤： 

1，定义类继承Thread类； 

2，目的是复写run方法，将要让线程运行的代码都存储到run方法中； 

3，通过创建Thread类的子类对象，创建线程对象； 

4，调用线程的start方法，开启线程，并执行run方法。 

线程状态： 

1新建：start() 

2运行：具备执行资格，同时具备执行权； 

3休眠：sleep(time),wait()—notify()唤醒；线程释放了执行权，同时释放执行资格； 临时

4阻塞状态：线程具备cpu的执行资格，没有cpu的执行权； 

5消亡：stop() 

例子：

package com.OpenWealth.ZSY;



import java.io.*;

import java.net.*;



public class TCPServer{

    

    

    @SuppressWarnings("resource")

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

        

        ServerSocket ss=null;

        ss=new ServerSocket(8866);

        while(true){



            try {

                

                Socket soc=ss.accept();

                

                new MyPicServerThread(soc).start();//开启服务端接受图片的线程

                

            } catch (IOException e) {

                // TODO Auto-generated catch block

                e.printStackTrace();

            }

        }

    }

    

    

    

    /***

     * 实现了多用户并发上传图片的服务端

     * @author 支胜勇

     *

     */

    public static class MyPicServerThread extends Thread{

        

        

        private Socket soc=null;

        

        public MyPicServerThread(Socket _soc){

            this.soc=_soc;

        }

        

        @Override

        public void run() {

            // TODO Auto-generated method stub

            String clientIp=soc.getInetAddress().getHostAddress();

            try {



                System.out.println(clientIp+"已连接！");

                

                InputStream in=soc.getInputStream();

                

                FileOutputStream fos=new FileOutputStream("E:\\TcpTest.png");

                

                byte[] buff=new byte[1024];

                

                int len=0;

                

                while((len=in.read(buff))!=-1){

                    

                    fos.write(buff,0,len);

                }

                

                OutputStream out=soc.getOutputStream();

                

                out.write("图片上传成功！".getBytes());

                

                fos.close();

                

                soc.close();

                

            } catch (IOException e) {

                // TODO Auto-generated catch block

                throw new RuntimeException("客户端"+clientIp+"上传失败");

            }

            

        } 

    }

}

 

（二）创建线程的第二种方式：

实现一个接口Runnable。 

步骤： 

1，定义类实现Runnable接口。 

2，覆盖接口中的run方法（用于封装线程要运行的代码）。 

3，通过Thread类创建线程对象； 

4，将实现了Runnable接口的子类对象作为实际参数传递给Thread类中的构造函数。 为什么要传递呢？因为要让线程对象明确要运行的run方法所属的对象。 

5，调用Thread对象的start方法。开启线程，并运行Runnable接口子类中的run方法。 

如：Ticket t = new Ticket(); 

直接创建Ticket对象，并不是创建线程对象。 

因为创建对象只能通过new Thread类，或者new Thread类的子类才可以。 所以最终想要创建线程。既然没有了Thread类的子类，就只能用Thread类。 

Thread t1 = new Thread(t); //创建线程。 

只要将t作为Thread类的构造函数的实际参数传入即可完成线程对象和t之间的关联 

为什么要将t传给Thread类的构造函数呢？其实就是为了明确线程要运行的代码run方法。 

例子：

package com.OpenWealth.ZSY;



import java.io.File;

import java.io.FileNotFoundException;

import java.io.IOException;

import java.net.*;

import java.util.ArrayList;

import java.util.List;

import java.io.*;

public class TCPClientSocket {

    

    

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

        

        BufferedReader buff=new BufferedReader(new InputStreamReader(System.in));

        

        //同时上传多张图片

        while(true){

            String imgUrl=buff.readLine();

            new Thread(new MyUpLoadPicClient(imgUrl,"localhost",8866)).start();

        }

        

    }

    

    

    /**

     * 实现了同时上传多张图片的客户端；可以上传多种格式的图片

     * @author 支胜勇

     *

     */

    public static class MyUpLoadPicClient implements Runnable{

        

        private File imgFile;

        

        private String ip;

        

        private int port;

        

        private Socket soc;

        

        private List<String> extensList=null;

        

        private OutputStream out;

        private FileInputStream fis;

        

        

        /***

         * 初始化构造方法

         * @param imgUrl

         * @param ip:服务器IP地址

         * @param port:服务器端口

         * @throws Exception

         */

        public MyUpLoadPicClient(String imgUrl,String ip,int port) throws Exception{

            

            this.imgFile=new File(imgUrl);

            this.ip=ip;

            this.port=port;

            

            extensList=new ArrayList<String>();

            extensList.add(".jpg");

            extensList.add(".png");

            extensList.add(".gif");

            extensList.add(".jpeg");

            extensList.add(".bmp");

            

        }

        

        

        public boolean isImg(){

            

            if(!imgFile.exists()){//||!imgFile.isFile()

                System.out.println("图片不存在，请重新上传！");

                return false;

            }

            

            if(!imgFile.isFile()){//||!imgFile.isFile()

                System.out.println("不是图片文件，请重新上传！");

                return false;

            }

            

            String extenName=imgFile.getName().substring(imgFile.getName().lastIndexOf(".")).toLowerCase();

            if(!extensList.contains(extenName)){

                

                System.out.println("请上传jpg,png,gif,bmp,jpeg格式的图片");

                return false;

            }

            

            if(imgFile.length()>1024*1024*5){

                System.out.println("图片过大，请上传5m以内的图片！");

                return false;

            }

            

            try {

                

                fis=new FileInputStream(imgFile);

                

            } catch (FileNotFoundException e) {

                // TODO Auto-generated catch block

                e.printStackTrace();

            }

            return true;

        }

        



        /***

         * 执行向服务器上传图片的代码

         */

        @Override

        public void run() {

            // TODO Auto-generated method stub

            if(!isImg()){

                return;

            }else{

                try {

                    this.soc=new Socket(this.ip,this.port);

                    out=soc.getOutputStream();

                    byte[] buff=new byte[1024];

                    int len=0;

                    while( (len=fis.read(buff)) != -1 ){

                        

                        out.write(buff,0,len);

                    }

                    soc.shutdownOutput();//告诉服务器上传结束

                    

                    InputStream in=soc.getInputStream();

                    

                    byte[] bufIn=new byte[1024];

                    

                    int num=in.read(bufIn);

                    

                    System.out.println(new String(bufIn,0,num));

                    

                    fis.close();

                    out.close();

                    soc.close();

                } catch (IOException e) {

                    // TODO Auto-generated catch block

                    e.printStackTrace();

                }

                

            }

        }

    }

}

 

（三）多线程安全问题的原因： 

通过图解：发现一个线程在执行多条语句时，并运算同一个数据时，在执行过程中，其他线程参与进来，并操作了这个数据。导致到了错误数据的产生。 

涉及到两个因素： 

1，多个线程在操作共享数据。 

2，有多条语句对共享数据进行运算。 

原因：这多条语句，在某一个时刻被一个线程执行时，还没有执行完，就被其他线程执行了。 

解决安全问题的原理： 只要将操作共享数据的语句在某一时段让一个线程执行完，在执行过程中，其他线程不能进来执行就可以解决这个问题。 

如何进行多句操作共享数据代码的封装呢？ 

java中提供了一个解决方式：就是同步代码块。 

格式： 

synchronized(对象) {  // 任意对象都可以。这个对象就是锁。 

需要被同步的代码； } 

Synchronized(自己的会写得出)  

wait和sleep区别：

 分析这两个方法：从执行权和锁上来分析： 

wait：可以指定时间也可以不指定时间。不指定时间，只能由对应的notify或者notifyAll来唤醒。 

sleep：必须指定时间，时间到自动从冻结状态转成运行状态(临时阻塞状态)。 

wait：线程会释放执行权，而且线程会释放锁。 

Sleep：线程会释放执行权，但不是不释放锁。 

三、JDK1.5新特性 

（一）Collection在jdk1.5以后，有了一个父接口Iterable，这个接口的出现的将iterator方法进行抽取，提高了扩展性。 

（二）增强for循环： 

foreach语句，foreach简化了迭代器。 

格式：// 增强for循环括号里写两个参数，第一个是声明一个变量，第二个就是需要迭代的容器 

for( 元素类型 变量名 : Collection集合 & 数组 ) { „ } 

高级for循环和传统for循环的区别： 

高级for循环在使用时，必须要明确被遍历的目标。这个目标，可以是Collection集合或者数组，如果遍历Collection集合，在遍历过程中还需要对元素进行操作，比如删除，需要使用迭代器。 

如果遍历数组，还需要对数组元素进行操作，建议用传统for循环因为可以定义角标通过角标操作元素。如果只为遍历获取，可以简化成高级for循环，它的出现为了简化书写。 高级for循环可以遍历map集合吗？不可以。但是可以将map转成set后再使用foreach语句。 

1)、作用：对存储对象的容器进行迭代： 数组  collection   map 

2)、增强for循环迭代数组： 

String [] arr = {"a", "b", "c"};//数组的静态定义方式，只试用于数组首次定义的时候 

for(String s : arr) { System.out.println(s); } 

3)、单列集合 Collection： 

List list = new ArrayList(); list.add("aaa"); // 增强for循环, 没有使用泛型的集合能不能使用增强for循环迭代？能 for(Object obj : list) { String s = (String) obj; System.out.println(s); } 

4)、双列集合 Map： 

package com.ItHeima.WeekAct;



import java.util.HashMap;

import java.util.Iterator;

import java.util.Map;

import java.util.Map.Entry;

import java.util.Set;



public class Test5 {

    public static void main(String[] args){

        

        Map<String, String> map = new HashMap<String, String>(); 



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



        // 传统方式

        Set entrys = map.entrySet(); 

        // 1.获得所有的键值对Entry对象

         Iterator iter = entrys.iterator(); 



        // 2.迭代出所有的entry 

        while(iter.hasNext()) { 



        Map.Entry entry = (Entry) iter.next(); 



        String key = (String) entry.getKey(); // 分别获得key和value 



        String value = (String) entry.getValue(); System.out.println(key + "=" + value); } 



        // 增强for循环迭代：原则上map集合是无法使用增强for循环来迭代的，因为增强for循环只能针对实现了Iterable接口的集合进行迭代；Iterable是jdk5中新定义的接口，就一个方法iterator方法，只有实现了Iterable接口的类，才能保证一定有iterator方法，java有这样的限定是因为增强for循环内部还是用迭代器实现的，而实际上，我们可以通过某种方式来使用增强for循环。

        for(Object obj : map.entrySet()) { 



        Map.Entry entry = (Entry) obj;  // obj 依次表示Entry 



        System.out.println(entry.getKey() + "=" + entry.getValue()); } 

        //5）、集合迭代注意问题：在迭代集合的过程中，不能对集合进行增删操作（会报并发访问异常）；可以用迭代器的方法进行操作（子类listIterator：有增删的方法）。 

        //6)、增强for循环注意问题：在使用增强for循环时，不能对元素进行赋值； 

        int[] arr = {1,2,3}; for(int num : arr) { num = 0; //不能改变数组的值 } 



        System.out.println(arr[1]); //2

    }

    }

}

（三）可变参数（...）

用到函数的参数上，当要操作的同一个类型元素个数不确定的时候，可是用这个方式，这个参数可以接受任意个数的同一类型的数据。 和以前接收数组不一样的是： 

以前定义数组类型，需要先创建一个数组对象，再将这个数组对象作为参数传递给函数。现在，直接将数组中的元素作为参数传递即可。底层其实是将这些元素进行数组的封装，而这个封装动作，是在底层完成的，被隐藏了。所以简化了用户的书写，少了调用者定义数组的动作。 

如果在参数列表中使用了可变参数，可变参数必须定义在参数列表结尾(也就是必须是最后一个参数，否则编译会失败。)。 

如果要获取多个int数的和呢？可以使用将多个int数封装到数组中，直接对数组求和即可。 

（四）静态导入

导入了类中的所有静态成员，简化静态成员的书写。 

import static java.util.Collections.*;  //导入了Collections类中的所有静态成员

（五）枚举

关键字 enum 

问题：对象的某个属性的值不能是任意的，必须为固定的一组取值其中的某一个； 解决办法： 1）、在setGrade方法中做判断，不符合格式要求就抛出异常； 2）、直接限定用户的选择，通过自定义类模拟枚举的方式来限定用户的输入，写一个Grade类，私有构造函数，对外提供5个静态的常量表示类的实例； 3)、jdk5中新定义了枚举类型，专门用于解决此类问题； 

4)、枚举就是一个特殊的java类，可以定义属性、方法、构造函数、实现接口、继承类； 

自动拆装箱：java中数据类型分为两种 ： 基本数据类型   引用数据类型(对象) 

在 java程序中所有的数据都需要当做对象来处理，针对8种基本数据类型提供了包装类，如下： 

int --> Integer byte --> Byte short --> Short long --> Long char --> Character 

例子：

package com.OpenWealth.Traffic;







/***

 * 关于方向的枚举类

 * @author 支胜勇

 *

 */

public enum Direction {

    

    EAST{



        @Override

        public Direction reverse() {

            // TODO Auto-generated method stub

            return WEST;

        }



        @Override

        public Direction positive() {

            // TODO Auto-generated method stub

            return EAST;

        }



        @Override

        public Direction leftSide() {

            // TODO Auto-generated method stub

            return SOUTH;

        }



        @Override

        public Direction rightSide() {

            // TODO Auto-generated method stub

            return NORTH;

        }

        

        

    },

    SOUTH{



        @Override

        public Direction reverse() {

            // TODO Auto-generated method stub

            return SOUTH;

        }



        @Override

        public Direction positive() {

            // TODO Auto-generated method stub

            return NORTH;

        }



        @Override

        public Direction leftSide() {

            // TODO Auto-generated method stub

            return WEST;

        }



        @Override

        public Direction rightSide() {

            // TODO Auto-generated method stub

            return EAST;

        }

        

    }

    ,WEST{



        @Override

        public Direction reverse() {

            // TODO Auto-generated method stub

            return WEST;

        }



        @Override

        public Direction positive() {

            // TODO Auto-generated method stub

            return EAST;

        }



        @Override

        public Direction leftSide() {

            // TODO Auto-generated method stub

            return NORTH;

        }



        @Override

        public Direction rightSide() {

            // TODO Auto-generated method stub

            return SOUTH;

        }

        

        

    },NORTH{



        @Override

        public Direction reverse() {

            // TODO Auto-generated method stub

            return NORTH;

        }



        @Override

        public Direction positive() {

            // TODO Auto-generated method stub

            return SOUTH;

        }



        @Override

        public Direction leftSide() {

            // TODO Auto-generated method stub

            return EAST;

        }



        @Override

        public Direction rightSide() {

            // TODO Auto-generated method stub

            return WEST;

        }

    };

    

    

    /**

     * 该方向的反方向

     * @return

     */

    public abstract Direction reverse();

    

    

    /**

     * 该方向的正方向

     * @return

     */

    public abstract Direction positive();

    

    

    /**

     * 该方向的左面

     * @return

     */

    public abstract Direction leftSide();

    

    

    /**

     * 该方向的右面

     * @return

     */

    public abstract Direction rightSide();

    

}

 

四、高新技术 

（一）反射  

反射技术：其实就是动态加载一个指定的类，并获取该类中的所有的内容。而且将字节

码文件封装成对象，并将字节码文件中的内容都封装成对象，这样便于操作这些成员。简单说：反射技术可以对一个类进行解剖。 反射的好处：大大的增强了程序的扩展性。 反射的基本步骤： 

1、获得Class对象，就是获取到指定的名称的字节码文件对象。 

2、实例化对象，获得类的属性、方法或构造函数。 

3、访问属性、调用方法、调用构造函数创建对象。 

获取这个Class对象，有三种方式： 

1：通过每个对象都具备的方法getClass来获取。弊端：必须要创建该类对象，才可以调用getClass方法。 

2：每一个数据类型(基本数据类型和引用数据类型)都有一个静态的属性class。弊端：必须要先明确该类。 

 前两种方式不利于程序的扩展，因为都需要在程序使用具体的类来完成。 

3：使用Class类中的方法，静态的forName方法。 

 指定什么类名，就获取什么类字节码文件对象，这种方式的扩展性最强，只要将类名的字符串传入即可。 

// 1. 根据给定的类名来获得  用于类加载 

        String classname = "cn.itcast.reflect.Person";// 来自配置文件 

        Class clazz = Class.forName(classname);// 此对象代表Person.class 

        // 2. 如果拿到了对象，不知道是什么类型   用于获得对象的类型 

        Object obj = new Person(); 

        Class clazz1 = obj.getClass();// 获得对象具体的类型 

        // 3. 如果是明确地获得某个类的Class对象  主要用于传参 Class clazz2 = Person.class; 

        //反射的用法： 

        //1）、需要获得java类的各个组成部分，首先需要获得类的Class对象，获得Class对象的三种方式： 

        Class.forName(classname) //用于做类加载 

        obj.getClass() //用于获得对象的类型 类名.class     用于获得指定的类型，传参用 

        //2)、反射类的成员方法： 

        Class clazz = Person.class; 

        Method method = clazz.getMethod(methodName, new Class[]{paramClazz1, paramClazz2}); method.invoke(); 

        //3)、反射类的构造函数： 

        Constructor con = clazz.getConstructor(new Class[]{paramClazz1, paramClazz2,...}) con.newInstance(params...) 

        //4)、反射类的属性： 

        Field field = clazz.getField(fieldName); field.setAccessible(true); field.setObject(value); 

获取了字节码文件对象后，最终都需要创建指定类的对象： 

创建对象的两种方式(其实就是对象在进行实例化时的初始化方式)： 

1，调用空参数的构造函数：使用了Class类中的newInstance()方法。 

2，调用带参数的构造函数：先要获取指定参数列表的构造函数对象，然后通过该构造函数的对象的newInstance(实际参数) 进行对象的初始化。 

综上所述，第二种方式，必须要先明确具体的构造函数的参数类型，不便于扩展。所以一般情况下，被反射的类，内部通常都会提供一个公有的空参数的构造函数。 

// 如何生成获取到字节码文件对象的实例对象。 

        Class clazz  =  Class.forName("cn.itcast.bean.Person"); //类加载 

        // 直接获得指定的类型 

        clazz  =  Person.class; 

        // 根据对象获得类型 

        Object obj  =  new Person("zhangsan",  19); 

        clazz  =  obj.getClass(); 

        Object obj  =  clazz.newInstance(); //该实例化对象的方法调用就是指定类中的空参数构造函数，给创建对象进行初始化。当指定类中没有空参数构造函数时，该如何创建该类对象呢？请看method_2(); 

        public static void method_2() throws Exception  { 

            Class clazz  =  Class.forName("cn.itcast.bean.Person"); 

        }

        //既然类中没有空参数的构造函数,那么只有获取指定参数的构造函数,用该函数来进行实例化。 

        //获取一个带参数的构造器。 

        Constructor constructor  =  clazz.getConstructor(String.class, int.class);  //想要对对象进行初始化，使用构造器的方法newInstance(); 

        Object obj = constructor.newInstance("zhagnsan",30); //获取所有构造器。 

        Constructor[] constructors  =  clazz.getConstructors(); //只包含公共的 

        constructors = clazz.getDeclaredConstructors();//包含私有的 

        for(Constructor con : constructors) { 

            System.out.println(con); 

        } 



         //反射指定类中的方法：  //获取类中所有的方法。 

         public static void method_1() throws Exception  { 

            Class clazz  =  Class.forName("cn.itcast.bean.Person"); 

            Method[] methods  =  clazz.getMethods(); //获取的是该类中的公有方法和父类中的公有方法。 

        }

         methods  =  clazz.getDeclaredMethods(); //获取本类中的方法，包含私有方法。 for(Method method : methods) { System.out.println(method); } } 

         //获取指定方法； 

         public static void method_2() throws Exception  { 

             Class clazz  =  Class.forName("cn.itcast.bean.Person");  //获取指定名称的方法。 

         }

         Method method  =  clazz.getMethod("show",  int.class, String.class); 

         //想要运行指定方法，当然是方法对象最清楚，为了让方法运行，调用方法对象的invoke方法即可，但是方法运行必须要明确所属的对象和具体的实际参数。 Object obj = clazz.newInstance(); 

         method.invoke(obj,  39, "hehehe"); //执行一个方法 } 

         //想要运行私有方法。 

         public static void method_3() throws Exception  { 

             Class clazz  =  Class.forName("cn.itcast.bean.Person");  //想要获取私有方法。必须用getDeclearMethod(); 

         }

         Method method  =  clazz.getDeclaredMethod("method",  null); 

        // 私有方法不能直接访问，因为权限不够。非要访问，可以通过暴力的方式。 method.setAccessible(true);//一般很少用，因为私有就是隐藏起来，所以尽量不要访问。 } 

        //反射静态方法。 

        public static void method_4() throws Exception  { 

             Class clazz  =  Class.forName("cn.itcast.bean.Person"); 

             Method method  =  clazz.getMethod("function", null); 

             method.invoke(null, null); 

        }