目录

​​1. 构造方法​​

​​1.1 构造方法概述【理解】​​

​​1.2 构造方法的注意事项【理解】​​

​​1.3 标准类制作【应用】 ​​

​​2 static（应用）​​

​​2.1 static访问特点（掌握）​​

​​3.反射​​

​​3.1反射的概述【理解】​​

​​3.2获取Class类对象的三种方式【应用】​​

​​3.2.1三种方式分类​​

​​3.2.2示例代码​​

​​3.3反射获取构造方法并使用【应用】​​

​​3.3.1Class类获取构造方法对象的方法​​

1. 构造方法

1.1 构造方法概述【理解】

构造方法是一种特殊的方法

作用：

创建对象 Student stu = new Student();

格式：

public class 类名{
修饰符 类名( 参数 ) {
}
}

功能：主要是完成对象数据的初始化

示例代码：

class Student {
    private String name;
    private int age;
    //构造方法
    public Student() {
        System.out.println("无参构造方法");
    }
    public void show() {
        System.out.println(name + "," + age);
    }
}
/*
测试类
*/
public class StudentDemo {
    public static void main(String[] args) {
//创建对象
        Student s = new Student();
        s.show();
    }
}

1.2 构造方法的注意事项【理解】

1.构造方法的创建

如果没有定义构造方法，系统将给出一个默认的无参数构造方法 如果定义了构造方法，系统将不再提供默认的构造

2.方法构造方法的重载

如果自定义了带参构造方法，还要使用无参数构造方法，就必须再写一个无参数构造方法

3.推荐的使用方式

无论是否使用，都手工书写无参数构造方法

4.重要功能

可以使用带参构造，为成员变量进行初始化

示例代码

/*
学生类
*/
class Student {
    private String name;
    private int age;
    public Student() {}
    public Student(String name) {
        this.name = name;
    }
    public Student(int age) {
        this.age = age;
    }
    public Student(String name,int age) {
        this.name = name;
        this.age = age;
    }
    public void show() {
        System.out.println(name + "," + age);
    }
}
/*
测试类
*/
public class StudentDemo {
    public static void main(String[] args) {
//创建对象
        Student s1 = new Student();
        s1.show();
//public Student(String name)
        Student s2 = new Student("林青霞");
        s2.show();
//public Student(int age)
        Student s3 = new Student(30);
        s3.show();
//public Student(String name,int age)
        Student s4 = new Student("林青霞",30);
        s4.show();
    }
}

1.3 标准类制作【应用】

需求：定义标准学生类，要求分别使用空参和有参构造方法创建对象，空参创建的对象通过setXxx赋值，有参创建的对象直接赋值，并通过show方法展示数据。

示例代码：


class Student {
    //成员变量
    private String name;
    private int age;
    //构造方法
    public Student() {
    }
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    //成员方法
    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public int getAge() {
        return age;
    }
    public void show() {
        System.out.println(name + "," + age);
    }
}
/*
创建对象并为其成员变量赋值的两种方式
1:无参构造方法创建对象后使用setXxx()赋值
2:使用带参构造方法直接创建带有属性值的对象
*/
public class StudentDemo {
    public static void main(String[] args) {
//无参构造方法创建对象后使用setXxx()赋值
        Student s1 = new Student();
        s1.setName("林青霞");
        s1.setAge(30);
        s1.show();
//使用带参构造方法直接创建带有属性值的对象Student s2 = new Student("林青霞",30);
        s2.show();
    }
}

2 static（应用）

static的概念

static关键字是静态的意思，可以修饰【成员方法】，【成员变量】

static修饰的特点

1. 被类的所有对象共享，这也是我们判断是否使用静态关键字的条件

2. 可以通过类名调用当然，也可以通过对象名调用【推荐使用类名调用】

示例代码：

class Student {
    public String name; //姓名
    public int age; //年龄
    public static String university; //学校 共享数据！所以设计为静态！
    public void show() {
        System.out.println(name + "," + age + "," + university);
    }
}
public class StaticDemo {
    public static void main(String[] args) {
// 为对象的共享数据赋值
        Student s1 = new Student();
        s1.name = "林青霞";
        s1.age = 30;
        s1.show();
        Student s2 = new Student();
        s2.name = "风清扬";
        s2.age = 33;
        s2.show();
    }
}

2.1 static访问特点（掌握）

static的访问特点

非静态的成员方法

能访问静态的成员变量

能访问非静态的成员变量

能访问静态的成员方法

能访问非静态的成员方法

静态的成员方法

能访问静态的成员变量

能访问静态的成员方法

总结成一句话就是： 静态成员方法只能访问静态成员

最后与静态变量一样，我们也可以使用 static 修饰方法，称为静态方法或类方法。其实之前我们一直写的 main 方法就是静态方法。静态方法的使用可以直接导入项目类文件之后类名调用方法，但是也可以实例化对象之后调用但是更推荐前者。

实例：

public class HelloWorld {

    // 定义静态变量score1
    static int score1 = 86;
    // 定义静态变量score2
              int score2 = 92; 

    // 定义静态方法sum，计算成绩总分，并返回总分
    public  static   int sum() { 
      HelloWorld hd=new HelloWorld(); 
     return score1+hd.score2;

    }

    public static void main(String[] args) {

        // 调用静态方法sum并接收返回值
        int allScore = HelloWorld.sum();

        System.out.println("总分：" + allScore);
    }
}

3.反射

3.1反射的概述【理解】

是指在运行时去获取一个类的变量和方法信息。然后通过获取到的信息来创建对象，调用方法的一种机制。

由于这种动态性，可以极大的增强程序的灵活性，程序不用在编译期就完成确定，在运行期仍然可以扩展

3.2获取Class类对象的三种方式【应用】

3.2.1三种方式分类


  2. 类名.class属性
  3. 对象名.getClass()方法
  4. Class.forName(全类名)方法

3.2.2示例代码 

public class ReflectDemo {
    public static void main(String[] args) throws ClassNotFoundException {
//使用类的class属性来获取该类对应的Class对象
        Class<Student> c1 = Student.class;
        System.out.println(c1);
        Class<Student> c2 = Student.class;
        System.out.println(c1 == c2);
        System.out.println("--------");
//调用对象的getClass()方法，返回该对象所属类对应的Class对象
        Student s = new Student();
        Class<? extends Student> c3 = s.getClass();
        System.out.println(c1 == c3);
        System.out.println("--------");
//使用Class类中的静态方法forName(String className)
        Class<?> c4 = Class.forName("com.itheima_02.Student");
        System.out.println(c1 == c4);
    }
}

3.3反射获取构造方法并使用【应用】

3.3.1Class类获取构造方法对象的方法

方法分类


Spring学习中用到的一些面向对象的知识_类名

示例代码

public class ReflectDemo01 {
    public static void main(String[] args) throws ClassNotFoundException,
            NoSuchMethodException, IllegalAccessException, InvocationTargetException,
            InstantiationException {
//获取Class对象
        Class<?> c = Class.forName("com.itheima_02.Student");
//Constructor<?>[] getConstructors() 返回一个包含 Constructor对象的数组，
        Constructor对象反映了由该 Class对象表示的类的所有公共构造函数
// Constructor<?>[] cons = c.getConstructors();
//Constructor<?>[] getDeclaredConstructors() 返回反映由该 Class对象表示的类
        声明的所有构造函数的 Constructor对象的数组
        Constructor<?>[] cons = c.getDeclaredConstructors();
        for(Constructor con : cons) {
            System.out.println(con);
        }
        System.out.println("--------");
//Constructor<T> getConstructor(Class<?>... parameterTypes) 返回一个
        Constructor对象，该对象反映由该 Class对象表示的类的指定公共构造函数
//Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes) 返回
        一个 Constructor对象，该对象反映由此 Class对象表示的类或接口的指定构造函数
//参数：你要获取的构造方法的参数的个数和数据类型对应的字节码文件对象
        Constructor<?> con = c.getConstructor();
//Constructor提供了一个类的单个构造函数的信息和访问权限
//T newInstance(Object... initargs) 使用由此 Constructor对象表示的构造函数，
        使用指定的初始化参数来创建和初始化构造函数的声明类的新实例
        Object obj = con.newInstance();
        System.out.println(obj);
// Student s = new Student();
// System.out.println(s);
    }
}