JAVA基础

JAVA基础

面向对象和面向过程

 面向过程

从功能的角度出发,把一个复杂的功能,一步一步细分为小的简单功能,然后按照一定的流程顺序执行.通过函数来实现小功能,从而完成整体功能

面向过程最大的问题在于随着系统的膨胀，面向过程将无法应付，最终导致系统的崩溃。为了解决这一种软件危机，我们提出面向对象思想。

另外,由于通过函数完成功能,实现比较抽象.一旦功能流程有所改动,扩展性差和维护难度大

面向对象

实现更低的耦合和更高的内聚,所有的行为都通过实例来调用成员方法实现,把不同的行为划分为不同的类,若干类集合,实现一个功能模块,模块之间通过接口来约定调用和被调用,这样开发人员关注不同模块的功能实现,模块内部通过类来实现功能

封装是指将对象的实现细节隐藏起来，然后通过公共的方法来向外暴露该对象的功能

继承是面向对象实现软件复用的重要手段，当子类继承父类后，子类是一种特殊的父类，能直接或简介获得父类里的成员

多态是可以直接把子类对象赋给父类变量，但是运行时依然表现出子类的行为特征，这意味着同一类型的对象在运行时可能表现出不同的行为特征
 

继承的优缺点

优点:创建子类的对象时，无须创建父类的对象,实现代码复用,减少了创建新类的代码冗余

缺点:子类和父类严密耦合,限制了子类的实现自由度,由于子类可能使用不到父类的方法,造成了新的代码冗余

反射机制

在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

反射的用途

1，在运行时判断任意一个对象所属的类；

2，在运行时构造任意一个类的对象；

3，在运行时判断任意一个类所具有的成员变量和方法；

4，在运行时调用任意一个对象的方法；

5，生成动态代理

在一个Integer数组中存储String类型

public static void main(String[] args){
        ArrayList<Integer> list=new ArrayList<>();
        list.add(111);
        Class<?> clz=list.getClass();
        try {
            Method method=clz.getMethod("add",Object.class);
            method.invoke(list,"time");

        } catch (IllegalAccessException | InvocationTargetException|NoSuchMethodException e) {
            e.printStackTrace();
        }

        for (int i=0;i<list.size();i++){
            System.out.println(list.get(i));
        }

    }

通过反射获取成员变量和成员方法

自己新建一个java类

public class Book {
    private String name;
    private int age;
    private double price;
    private BookWriter mWriter;

    public Book() {
        name="书的名字";
        age=0;
        price=1.00;
        mWriter=new BookWriter("wwq");
    }

    public Book(String name, int age, double price, BookWriter writer) {
        this.name = name;
        this.age = age;
        this.price = price;
        mWriter = writer;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public BookWriter getWriter() {
        return mWriter;
    }

    public void setWriter(BookWriter writer) {
        mWriter = writer;
    }

    public class BookWriter {
        private String name;

        public BookWriter(String name) {
            this.name = name;
        }

        public String getName() {
            return name;
        }

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

然后通过反射获取构造器方法,获取成员变量和成员方法

public static void main(String[] args){
        Book book=new Book();

        Class<?> clazz=book.getClass();
        System.out.println("book.class="+clazz.toString());
        try {
            Constructor<?> constructor=clazz.getConstructor();
            System.out.println("constructor="+constructor.toString());
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }
        try {
            Method setNameMethod=clazz.getMethod("setName",String.class);
            System.out.println("setNameMethod="+setNameMethod.toString());
            try {
                System.out.println("before book.name="+book.getName());
                setNameMethod.invoke(book,"newBook");
                System.out.println("after book.name="+book.getName());
            } catch (IllegalAccessException | InvocationTargetException e) {
                e.printStackTrace();
            }
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }

//        getFields()获取public属性的成员变量
//        getDeclaredFields()获取所有类型的成员变量
        Field[] fields=clazz.getDeclaredFields();

        System.out.println("fields.size="+fields.length);
        System.out.println("fields[0]="+fields[0].toString());
        System.out.println("fields[1]="+fields[1].toString());
        System.out.println("fields[2]="+fields[2].toString());
        System.out.println("fields[3]="+fields[3].toString());

        Field mWriter= null;
        try {
            mWriter = clazz.getDeclaredField("mWriter");
//            private属性的成员变量需要添加获取权限
            mWriter.setAccessible(true);
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        }
        System.out.println("mWriter="+mWriter.toString());
            try {
                Book.BookWriter bookWriter=(Book.BookWriter) mWriter.get(book);
                System.out.println("bookWriter.getName="+bookWriter.getName());
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
}