一、构造器

    Java中的构造器（Constructor）是一个特殊的方法，用于初始化新创建的对象的状态。构造器的方法名必须与类名完全相同，并且不能有任何返回类型，连void都没有。

Java构造器有以下几种：

1. 无参构造器：没有参数的构造器。
2. 带参构造器：具有一个或多个参数的构造器。

// 无参构造器
class Person {
    String name;

    Person() {
        System.out.println("无参构造器调用");
    }
}

// 带参构造器
class Person {
    String name;
    int age;

    Person(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("带参构造器调用");
    }
}

1. 一个类可以有多个构造器，但构造器的名称必须相同。这称为构造器重载。
2. 如果没有显式声明构造器，Java编译器会自动为类生成一个无参构造器。
3. 构造器不能被继承。
4. 构造器不能被继承，因此不能被覆盖。

class Parent {
    Parent() {
        System.out.println("Parent的无参构造器");
    }
}

class Child extends Parent {
    Child() {
        // 这里不会调用Parent的构造器，因为构造器不能被继承
        System.out.println("Child的无参构造器");
    }
}
在Java中，构造器是非常重要的，因为它们是对象生命周期中的第一个调用的方法，用于初始化对象的状态。

java的四种修饰符：public、private、protected、default

二、assert 断言表达式是否为真

在Java中，assert关键字用于在程序中添加断言。断言是一种调试工具，它允许你在程序中设置一个条件，如果这个条件在执行某个代码块之前为假，那么程序将抛出一个AssertionError异常。这样可以帮助开发者快速发现程序中的逻辑错误。

使用断言时需要注意以下几点：

1. 断言在默认情况下是禁用的，需要在运行程序时使用-ea参数启用。例如，使用命令行参数java -ea MyProgram来启用断言。

2. 断言在生产环境中通常是禁用的，因为它们不会影响程序的输出结果，而且可能会对性能造成轻微影响。

3. 断言不能用在静态方法中。

4. 断言不能用return、continue或break语句跟随。

public class AssertExample {
    public static void main(String[] args) {
        assert args.length == 2 : "参数个数不正确";
        // 如果args.length不等于2，程序将抛出AssertionError
        System.out.println("参数个数正确");
    }
}
在这个例子中，如果args.length不等于2，程序将抛出一个包含"参数个数不正确"信息的AssertionError。如果args.length确实等于2，程序将继续执行并打印"参数个数正确"。

三、super 父类,超类   this 本类   void 无返回值

1. super：

   • super关键字用于引用父类（超类）的成员，包括方法和变量。
   • 它在子类中用来调用父类的构造方法或者访问父类的属性和方法。
   • 示例：super.methodName(); 或 super(arguments);

2. this：

   • this关键字用于引用当前类的成员，包括方法和变量。
   • 它在类的构造方法或者方法中用来区分同类成员。
   • 示例：this.variableName = value; 或 this.methodName();

3. void：

   • void是一个返回类型，用来指明一个方法不返回任何值。
   • 通常用于那些执行某些操作但不产生结果的方法，如打印信息或抛出异常。
   • 示例：public void printMessage() { System.out.println("Hello, World!"); }

这些关键字在Java编程中经常使用，但它们的作用和用途是不同的。super和this用于处理当前类和父类之间的成员访问，而void用于指定一个方法不返回任何值。

四、创建对象

声明：声明一个对象，包括对象名称和对象类型。即用 如in dog 可以加修饰符private int dogeColor

实例化：使用关键字new来创建一个对象。

初始化：使用new创建对象时，会调用构造方法初始化对象。

/* 实例化对象 */

ObjectReference = new Constructor();

/* 访问类中的变量 */

ObjectReference.variableName;

/* 访问类中的方法 */

ObjectReference.methodName(); 即通过对象.来实现

五、构造方法

在创建一个对象的时候，至少要调用一个构造方法。构造方法的名称必须与类同名，一个类可以有多个构造方法。public class Puppy{

public Puppy(){

}

public Puppy(String name){

// 这个构造器仅有一个参数：name

}

}

六、变量类型

1、类变量：独立于方法之外的变量，用 static 修饰。

2、实例变量：独立于方法之外的变量，不过没有 static 修饰。

3、局部变量：类的方法中的变量

局部变量：

局部变量声明在方法、构造方法或者语句块中；

局部变量在方法、构造方法、或者语句块被执行的时候创建，当它们执行完成后，变量将会被销毁；

访问修饰符不能用于局部变量；

局部变量只在声明它的方法、构造方法或者语句块中可见；

局部变量是在栈上分配的。

局部变量没有默认值，所以局部变量被声明后，必须经过初始化，才可以使用。

实例变量：

实例变量声明在一个类中，但在方法、构造方法和语句块之外；

当一个对象被实例化之后，每个实例变量的值就跟着确定；

实例变量在对象创建的时候创建，在对象被销毁的时候销毁；

实例变量的值应该至少被一个方法、构造方法或者语句块引用，使得外部能够通过这些方式获取实例变量信息；

实例变量可以声明在使用前或者使用后；

访问修饰符可以修饰实例变量；

实例变量对于类中的方法、构造方法或者语句块是可见的。一般情况下应该把实例变量设为私有。通过使用访问修饰符可以使实例变量对子类可见；

实例变量具有默认值。数值型变量的默认值是0，布尔型变量的默认值是false，引用类型变量的默认值是null。变量的值可以在声明时指定，也可以在构造方法中指定；

实例变量可以直接通过变量名访问。但在静态方法以及其他类中，就应该使用完全限定名：ObejectReference.VariableName。

类变量（静态变量）：

类变量也称为静态变量，在类中以static关键字声明，但必须在方法构造方法和语句块之外。

无论一个类创建了多少个对象，类只拥有类变量的一份拷贝。

静态变量除了被声明为常量外很少使用。常量是指声明为public/private，final和static类型的变量。常量初始化后不可改变。

静态变量储存在静态存储区。经常被声明为常量，很少单独使用static声明变量。

静态变量在第一次被访问时创建，在程序结束时销毁。

与实例变量具有相似的可见性。但为了对类的使用者可见，大多数静态变量声明为public类型。

默认值和实例变量相似。数值型变量默认值是0，布尔型默认值是false，引用类型默认值是null。变量的值可以在声明的时候指定，也可以在构造方法中指定。此外，静态变量还可以在静态语句块中初始化。

静态变量可以通过：ClassName.VariableName的方式访问。

类变量被声明为public static final类型时，类变量名称一般建议使用大写字母。如果静态变量不是public和final类型，其命名方式与实例变量以及局部变量的命名方式一致。

七、访问修饰符

修饰符 当前类 同一包内    子孙类(同一包)       子孙类(不同包)     其他包

  public     Y             Y                 Y                             Y                       Y

protected  Y            Y                  Y                            Y/N（说明）     N

default        Y           Y                 Y                               N                     N

private         Y          N                N                                 N                   N

八、运算符

算术运算符 如- + * /

关系运算符 如=> < !=

位运算符

逻辑运算符

赋值运算符

其他运算符

位运算符

操作符                                  描述                                                              例子

＆      如果相对应位都是1，则结果为1，否则为0                   （A＆B），得到12，即0000 1100

|         如果相对应位都是0，则结果为0，否则为1                    （A | B）得到61，即 0011 1101

^        如果相对应位值相同，则结果为0，否则为1                    （A ^ B）得到49，即 0011 0001

〜      按位取反运算符翻转操作数的每一位，即0变成1，1变成0。 （〜A）得到-61，即1100 0011

<<     按位左移运算符。左操作数按位左移右操作数指定的位数。    A << 2得到240，即 1111 0000

>>      按位右移运算符。左操作数按位右移右操作数指定的位数。       A >> 2得到15即 1111

>>>    按位右移补零操作符。左操作数的值按右操作数指定的位数右移，移动得到的空位以零填充。                                                                                                       A>>>2得到15即0000 1111

九、javaNumber&math类：double float Integer long short byte 都是Numbers的子类

十、创建操作字符串的 javaString类：

字符串广泛应用 在Java 编程中，在 Java 中字符串属于对象，Java 提供了 String 类来创建和操作字符串。String 类使用静态方法 format() 返回一个String 对象而不是 PrintStream 对象。

String 类的静态方法 format() 能用来创建可复用的格式化字符串，而不仅仅是用于一次打印输出。

十一、数组

下面的图片描绘了数组 myList。这里 myList 数组里有 10 个 double 元素，它的下标从 0 到 9。

java数组结构说明

多维数组

多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组，例如：

String str[][] = new String[3][4];

Arrays 类

java.util.Arrays 类能方便地操作数组，它提供的所有方法都是静态的。

具有以下功能：

给数组赋值：通过 fill 方法。

对数组排序：通过 sort 方法,按升序。

比较数组：通过 equals 方法比较数组中元素值是否相等。

查找数组元素：通过 binarySearch 方法能对排序好的数组进行二分查找法操作

十二、Java 日期时间

Date对象创建以后，可以调用下面的方法。

序号     方法和描述

1      boolean after(Date date)

             若当调用此方法的Date对象在指定日期之后返回true,否则返回false。

2     boolean before(Date date)

              若当调用此方法的Date对象在指定日期之前返回true,否则返回false。

3      Object clone( )

              返回此对象的副本。

4     int compareTo(Date date)

                比较当调用此方法的Date对象和指定日期。两者相等时候返回0。调用对象在指定日期之前则返回负数。调用对象在指定日期之后则返回正数。

5      int compareTo(Object obj)

                   若obj是Date类型则操作等同于compareTo(Date) 。否则它抛出ClassCastException。

6     boolean equals(Object date)

                  当调用此方法的Date对象和指定日期相等时候返回true,否则返回false。

7     long getTime( )

                   返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。

8     int hashCode( )

                返回此对象的哈希码值。

9     void setTime(long time)

                  用自1970年1月1日00:00:00 GMT以后time毫秒数设置时间和日期。

10     String toString( )

                   把此 Date 对象转换为以下形式的 String： dow mon dd hh:mm:ss zzz yyyy 其中： dow 是一周中的某一天 (Sun, Mon, Tue, Wed, Thu, Fri, Sat)。

使用 SimpleDateFormat 格式化日期

Calendar类实现了公历日历，GregorianCalendar是Calendar类的一个具体实现。

Calendar 的getInstance（）方法返回一个默认用当前的语言环境和时区初始化的GregorianCalendar对象。GregorianCalendar定义了两个字段：AD和BC。这是代表公历定义的两个时代。

使用printf格式化日期使用printf格式化日期

Java 正则表达式

Java 正则表达式和 Perl 的是最为相似的。

java.util.regex 包主要包括以下三个类：

Pattern 类：

pattern 对象是一个正则表达式的编译表示。Pattern 类没有公共构造方法。要创建一个 Pattern 对象，你必须首先调用其公共静态编译方法，它返回一个 Pattern 对象。该方法接受一个正则表达式作为它的第一个参数。

Matcher 类：

Matcher 对象是对输入字符串进行解释和匹配操作的引擎。与Pattern 类一样，Matcher 也没有公共构造方法。你需要调用 Pattern 对象的 matcher 方法来获得一个 Matcher 对象。

PatternSyntaxException：

PatternSyntaxException 是一个非强制异常类，它表示一个正则表达式模式中的语法错误。

Java 方法

方法体：方法体包含具体的语句，定义该方法的功能。

修饰符：修饰符，这是可选的，告诉编译器如何调用该方法。定义了该方法的访问类型。

返回值类型 ：方法可能会返回值。returnValueType 是方法返回值的数据类型。有些方法执行所需的操作，但没有返回值。在这种情况下，returnValueType 是关键字void。

方法名：是方法的实际名称。方法名和参数表共同构成方法签名。

参数类型：参数像是一个占位符。当方法被调用时，传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的，方法可以不包含任何参数。

方法体：方法体包含具体的语句，定义该方法的功能。

方法调用

Java 支持两种调用方法的方式，根据方法是否返回值来选择。

当程序调用一个方法时，程序的控制权交给了被调用的方法。当被调用方法的返回语句执行或者到达方法体闭括号时候交还控制权给程序。

当方法返回一个值的时候，方法调用通常被当做一个值。

方法的重载

一个类的两个方法拥有相同的名字，但是有不同的参数列表。

finalize() 方法

在对象被垃圾收集器析构(回收)之前调用，这个方法叫做 finalize( )，它用来清除回收对象。

IO

一般代码可以分为静态和动态 静态不灵活 而动态则可以实现动态创建对象和编译，体现出很大的灵活性 反射通过 //f=(fruit)Class.forName(ClassName).newInstance(); }

从上可以看出 反射j即就是 Class.forName 会用到reflect ioc通过init()类来实现 properrties

IOC即就是通过一个poperties来实现 Reflection

IOC

1.使用反射机制并结合属性文件的工厂模式（即IoC (Reflection)”编程 根据给出的类名（字符串方式）来动态地生成对象，这种编程方式可以让对象在生成时才被决定到底是哪一种对象 2.把IOC容器的工作模式看做是工厂模式的升华，可以把IOC容器看作是一个工厂，这个工厂里要生产的对象都在配置文件中给出定义，然后利用编程语言提供的反射机制，根据配置文件中给出的类名生成相应的对象。 3.工作量不大的项目或者产品，不太适合使用IOC框架产品。特别强调运行效率的项目或者产品，也不太适合引入IOC框架产品，像WEB2.0网站就是这种情况

Aop

剖解开封装的对象内部，并将那些影响了多个类的公共行为封装到一个可重用模块，并将其命名为"Aspect"，即切面。所谓"切面"，简单说就是那些与业务无关，却为业务模块所共同调用的逻辑或责任封装起来，便于减少系统的重复代码，降低模块之间的耦合度，并有利于未来的可操作性和可维护性。 AOP把软件系统分为两个部分：核心关注点和横切关注点 业务处理的主要流程是核心关注点，横切关注点就是基本上每个业务都要使用的公共部分 与业务关系不大的部分是横切关注点

切面：类是对物体特征的抽象，切面就是对横切关注点的抽象

连接点：被拦截到的点，因为Spring只支持方法类型的连接点，所以在Spring中连接点指的就是被拦截到的方法，实际上连接点还可以是字段或者构造器

切入点：对连接点进行拦截的定义

通知：所谓通知指的就是指拦截到连接点之后要执行的代码，通知分为前置、后置、异常、最终、环绕通知五类

目标：代理的目标对象

织入：将切面应用到目标对象并导致代理对象创建的过程

Spring中AOP代理：由Spring的IOC容器负责生成、管理，其依赖关系也由IOC容器负责管理。

Spring创建代理的规则：

AOP编程其实是很简单的事情，纵观AOP编程，程序员只需要参与三个部分：

1、定义普通业务组件

2、定义切入点，一个切入点可能横切多个业务组件

3、定义增强处理，增强处理就是在AOP框架为普通业务组件织入的处理动作

Java 集合框架

该框架必须是高性能的。基本集合（动态数组，链表，树，哈希表）的实现也必须是高效的。

该框架允许不同类型的集合，以类似的方式工作，具有高度的互操作性。

对一个集合的扩展和适应必须是简单的

位集合（BitSet）

一个Bitset类创建一种特殊类型的数组来保存位值。BitSet中数组大小会随需要增加。这和位向量（vector of bits）比较类似。

枚举（Enumeration）

枚举（The Enumeration）接口定义了一种从数据结构中取回连续元素的方式。

public static void main(String args[]) {

Enumeration<String> days;

Vector<String> dayNames = new Vector<String>();

dayNames.add("Sunday");

dayNames.add("Monday");

dayNames.add("Tuesday");

dayNames.add("Wednesday");

dayNames.add("Thursday");

dayNames.add("Friday");

dayNames.add("Saturday");

days = dayNames.elements();

while (days.hasMoreElements()){

System.out.println(days.nextElement());

}

}

Java 数据结构

枚举（Enumeration）

位集合（BitSet）

向量（Vector）

栈（Stack）

字典（Dictionary）

哈希表（Hashtable）

属性（Properties）

Java 封装

封装最主要的功能在于我们能修改自己的实现代码，而不用修改那些调用我们代码的程序片段。

封装可以被认为是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问。

访问该类的代码和数据，必须通过严格的接口控制。

封装的优点

1. 良好的封装能够减少耦合。

2. 类内部的结构可以自由修改。

3. 可以对成员变量进行更精确的控制。

4. 隐藏信息，实现细节。

实现Java封装的步骤

1. 修改属性的可见性来限制对属性的访问,即改成private私有属性

2. 对每个值属性提供对外的公共方法访问，也就是创建一对赋取值方法，用于对私有属性的访问 即public 修饰

Java 抽象类

抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。抽象类不能实例化对象，所以抽象类必须被继承，才能被使用

Java 提供了 String 类来创建和操作字符串。

Java StringBuffer 和 StringBuilder 类

StringBuilder 的方法线程是不安全的，但StringBuilder比StringBuffer快

按速度排名StringBuilder>StringBuffer>String

当对字符串进行修改的时候，需要使用 StringBuffer 和 StringBuilder 类。

API

API（Application Programming Interface,应用程序编程接口）是一些预先定义的函数，目的是提供应用程序与开发人员基于某软件或硬件得以访问一组例程的能力，而又无需访问源码，或理解内部工作机制的细节。

API是一套用来控制Windows的各个部件的外观和行为的预先定义的Windows函数。用户的每个动作都会引发一个或几个函数的运行以告诉Windows发生了什么

asm

它以平台无关的方式提供了文件系统、逻辑卷管理器以及软件 RAID（磁盘阵列） 等服务。

ASM 可以条带化和镜像磁盘

支持直接和异步的 I/O 并使用 Oracle9i 中引入的 Oracle 数据管理器 API（简化的 I/O 系统调用接口

动态代理

动态代理类是位于Java.lang.reflect包下类别的Interface InvocationHandler

Proxy：该类即为动态代理类

Protected Proxy(InvocationHandler h）：构造函数，估计用于给内部的h赋值

Static Class getProxyClass (ClassLoader loader,Class[] interfaces）：获得一个代理类，其中loader是类装载器，interfaces是真实类所拥有的全部接口的数组。

代理机制及特点

通过实现 InvocationHandler 接口创建自己的调用处理器；

通过为 Proxy 类指定 ClassLoader 对象和一组 interface 来创建动态代理类；

通过反射机制获得动态代理类的构造函数，其唯一参数类型是调用处理器接口类型；

通过构造函数创建动态代理类实例，构造时调用处理器对象作为参数被传入。

test的测试类的编写

import java.io.*;

public class EmployeeTest{

public static void main(String []args){

/* 使用构造器创建两个对象 */

Employee empOne = new Employee("RUNOOB1");

Employee empTwo = new Employee("RUNOOB2");

// 调用这两个对象的成员方法

empOne.empAge(26);

empOne.empDesignation("高级程序员");

empOne.empSalary(1000);

empOne.printEmployee();

empTwo.empAge(21);

empTwo.empDesignation("菜鸟程序员");

empTwo.empSalary(500);

empTwo.printEmployee();

}

}

主类

import java.io.*;

public class Employee{

String name;

int age;

String designation;

double salary;

// Employee 类的构造器

public Employee(String name){

this.name = name;

}

// 设置age的值

public void empAge(int empAge){

age = empAge;

}

/* 设置designation的值*/

public void empDesignation(String empDesig){

designation = empDesig;

}

/* 设置salary的值*/

public void empSalary(double empSalary){

salary = empSalary;

}

/* 打印信息 */

public void printEmployee(){

System.out.println("名字:"+ name );

System.out.println("年龄:" + age );

System.out.println("职位:" + designation );

System.out.println("薪水:" + salary);

}

}