学习笔记12月以前

一、成员变量与局部变量的区别：

      定义的位置区别：

1、成员变量是定义在方法之外，类之内。

2、局部变量是定义在方法之内。

作用上的区别：

1、成员变量用于描述一类事物的公共属性。

2、局部变量提供一个变量给方法内部使用。

生命周期的区别：

1、随着对象的创建而创建，随着对象的消失而消失。

2、在调用了对应的方法时执行到了创建该变量的语句时存在，局部变量一旦出了自己的作用域那么马上从内存中消失。

初始值的区别：

1、成员变量是有默认的初始值。

数据类型          默认的初始值

 Int                      0

Float                     0.0f

Double                   0.0

Boolean                  false

Char                     “ ”//空字符

String(引用数据类型)       null                            

             2、局部变量是没有默认的初始值的，必须要先初始化才能使用。

二、1、实体类：用于描述一类事物的就称作实体类；（在现实开发中一般实体类的所有成员属性（成员变量）必须进行封装。）

       2、工具类：Arrays数组的工具类。

       3、封装的优点：

      a)      操作简单；

      b)     提高的数据的安全性；

      c)      隐藏了实现。

1、构造函数的作用：给对应的对象进行初始化

2、构造函数定义的格式：

修饰符（public） 函数名 （形式参数）{

      函数体……

}

3、构造函数注意事项

a)      构造函数没有返回值类型。

b)     构造函数的函数名必须与类名一致。

c)      构造函数并不是有我们手动调用的，而是在创建对应对象时，jvm（java虚拟机）就会主动调用到对应的构造函数。

d)     如果一个一个类没有显式的写上一个构造方法时，java编译器会自动弄为该类添加一个无参的构造函数。

注：java编译器添加的无参构造方法的权限修饰符与类的权限修饰符是一致的。

e)      如果一个一个类已经显式的写上一个构造方法时，java编译器不会自动为该类添加构造函数。

f)       构造函数可以在一个类中以函数重载的形式存在多个。

4、Javap反编译工具的使用格式：

Javap     -c    -l    -private  类名

 

5、构造函数与普通函数的区别

a)      返回值类型的区别：

1）、构造函数是没有返回值类型的‘。

2）、普通函数是有返回值类型的，即使没有返回值，返回值类型也要写上void。

      b）函数名的区别：

             1）、构造函数的函数名必须要与类名一致。

             2）、普通函数的函数名只要符合标识符的命名规则即可。

      c）调用方式的区别

             1）、构造方法是在创建对象的时候由jvm调用的，一个对象调用一次。

             2）、普通函数是由我们使用对象是调用的，一个对象可以调用多次普通的函数。

      b）作用上的区别

             1）、构造函数的作用与初始化一个对象。

             2)、普通函数是用于描述一类事物的公共行为。

代码块的类别：1）、构造代码块

                      2）、局部代码块

                      3）、静态代码块

1、构造代码块的格式

      {

             构造代码

}

注：   （1）、构造代码块的大括号必须位于成员位置之上

（2）、局部代码块的大括号位于方法之内，作用：缩短局部变量的生命周期，节，省一点点内存。

构造代码块要注意的事项：

1、java编译器编译一个java源文件的时候，会把成员变量的声明语句提前至一个类的最前端。

2、成员变量的初始化工作时期都在构造函数中执行的。

3、一旦经过java编译器编译后，那么构造代码块的代码就会被移动到构造函数中执行，是在构造函数之前执行的，构造函数中的代码是最后执行的。

成员变量的显示初始化与构造代码块的代码是按照当前代码的顺序执行的。

存在同名的局部变量和成员变量时，在方法的内部访问的时局部变量（java采取的时就近原则的机制访问的。）

 

This关键字代表了所属函数的调用者对象。

This关键字的作用

1、如果存在同名成员变量和局部变量时，在方法内部默认是访问局部变量的数据，可以通过this关键字指定访问成员变量。

2、在一个构造函数中可以调用另一个构造函数初始化对象。

This关键字的注意事项：如果在一个方法中访问了一个变量，该变量只存在成员变量的情况下，那么java编译器会在该变量的前面添加this关键字。

This关键字调用其他构造函数时注意的事项：

1、this关键字调用其它构造函数时，this关键字必须位于构造函数中的第一个语句。

2、this关键字在构造函数中不能出现相互调用的情况。（因为是一个死循环，叫递归构造器调用）

注：一个函数的形式参数也属于局部变量。

静态成员变量只会在数据共享区中维护一份，而分静态成员变量的数据会在每个对象中都维护一份的。

Static（静态/修饰符）

1、Static修饰成员变量

a)      如果有数据需要被共享给所有对象使用时，那么就可以使用Static修饰。

静态成员变量的访问方式：

      方式一：可以使用对象进行访问。

                    格式：对象.变量名。

      方式二：可以使用类名进行访问。

                    格式：类名.变量名。

注：1）、非静态的成员变量只能使用对象进行访问，不能使用类名进行访问。

2)、只有成员变量的数据是真正需要被共享时才可以用static进行修饰，不能为了方便访问数据而使用static修饰成员变量。

b） static修饰成员变量的应用场景：如果一个数据需要被所有对象共享使用时，用static进行修饰

Static修饰方法

      访问方式：

方式一：可以使用对象进行访问。

                                  格式：对象.静态函数名（）；

                    方式二：可以使用类名进行访问。

                                  格式：类名.静态函数名（）；

      推荐使用类名直接访问静态函数，不用创建对象，方便，且节省内存。

静态函数要注意的事项：

  1、静态函数是可以使用类名或者对象进行调用的    ，非静态函数只能使用对象进行调用。2、静态函数可以直接访问静态的成员，但是不能直接访问非静态的成员（因为没有对象存在）。因为静态函数是可以使用类名直接调用的这时候可能还没有对象存在，而非静态的成员数据是随着对象的存在而存在的。

  3、静态函数不能出现this或者super关键字。因为静态函数可以使用类名调用，一旦使用类名调用，这是候不存在对象，而this关键字是代表了一个函数的调用这对象，这时候产生了冲突。

4、非静态函数可以直接访问静态与非静态成员。因为非静态函数只能用对象调用，当对

象存在的时候，静态数据已经存在，而非静态数据随着对象的创建而存在。

 

静态数据的生命周期：静态成员变量数据是优先于对象存在的。

静态放法与非静态方法的字节码文件是同时存在内存中的，只是静态成员变量数据是优先于对象存在的。

Public：公共的。权限最大，为了保证jvm在任何情况下都可以访问到main主函数。

Static：静态的。静态可以让jvm调用main函数的时候更加的方便，不需要通过对象调用。

Void：没有返回值。因为返回的数据是返回给jvm的，而jvm使用这个数据没有意义的，所以就不要。

Main：函数名。注：main不是关键字，是jvm能识别的一个特殊函数名。

Arguments（args）：参数。担心某些程序在启动需要参数。

如果一个函数没有直接访问到非静态的成员时，那么就可以使用static修饰了，一般用于工具类型的方法。

静态的成员变量与非静态成员变量的区别

1、作用上的区别：a、静态成员变量的作用共享一个数据给所有对象使用。

             b、非静态成员变量的作用是描述一类事物的公共属性。

2、数量上的区别：a、静态成员变量是存储在方法内存中，而且只会存在一份数据。

             b、非静态成员变量是存储在堆内存中，有n个对象就有n份数据。

3、生命周期的区别：a、静态成员变量数据是随着类的加载而存在，随着类文件的消失     而消失。

b、非静态成员变量数据是随着对象的创建而存在，随着对象的消失而消失。

 

模式：模式就是解决一类问题的固定步骤。

软甲行业中23种设计模式

单例设计模式

模板设计模式

装饰者设计模式

观察者设计模式

工厂设计模式

 

单例设计模式：保证一个类在内存中只有一个对象。

单例设计模式步骤： 饿汉单例设计模式：

 1、私有化构造函数。

                                   2、声明本类的引用类型变量，并且使用该变量指向本类对象。

                                   3、提供一个公共的方法，获取本类的对象。

                              懒汉单例设计模式：

1、私有化构造函数。

2、声明本类的引用类型变量，但是不要创建对象。

3、提供公共静态的方法获取本类的对象，获取之前先判断是否已经创建了本类对象，如果已经创建了，那么直接返回对象即可，如果还没有创建，那么先创建本类的对象，然后在返回。

推荐使用饿汉单例设计模式，因为懒汉单例设计模式会存在线程安全问题，目前还不能保证一个类在内存中只有一个对象。

线程安全问题：cpu在一个时间片中只能有一个线程执行。

继承的格式：

        class  类名1 extends类名2{

}

 

继承时通过关键字extends体现的。

继承要注意的事项： 1、要符合实际情况，只有真正存在继承关系才用继承。

                                  2、父类私有的成员不能被继承。

                                  3、父类的构造函数不能被继承。

                                  4、创建子类对象时默认会先调用父类无参的构造函数。（调用父类构造方法是可以初始化从父类继承下去的属性的，）调用和继承没有任何关系。

instanceof关键字

instanceof关键字的作用：判断一个对象是否属于指定的类别。

instanceof关键字的使用前提：判断的对象与指定的类别必须要存在继承或者实现的关系。

instanceof关键字的使用格式：

              对象 instanceof类别

instanceof关键字的作用：一般我们做强制类型转化之前都会使用该关键字先判断一把，然后在进行转换。

super关键字

super关键字代表了父类空间的引用。

super关键字的作用：

1、子父类存在着同名的成员时，在子类中默认访问子类的成员，可以通过super关键字指定访问父类的成员。（成员包括变量和方法）

2、创建子类对象时，默认会先调用父类无参的构造方法，可以通过super关键字指定调用父类的构造方法。（包括无参和有参）

super关键字调用父类构造构造方法要注意的事项：

1、如果在子类的构造方法上没有指定调用父类的构造方法，java编译器会在子类的构造方法上加上super()语句。

2、super关键字调用父类的构造函数时，该语句必须要是子类构造函数中的第一个语句。

3、super和this关键字不能同时出现在同一个构造函数中调用其他的构造函数。因为两个语句都需要第一。

 

Super关键字this关键字的区别：

1、代表的事物不一致

a)      super关键字代表的是父类空间的引用。

b)     this关键字代表的是所属函数的调用者对象。

2、使用前提不一致

a)      super关键字必须要有继承关系才能使用。

b)     this关键字不需要存在继承关系也可以使用。

3、调用构造函数的区别

a)      super关键字是调用父类的构造函数。

b)     this关键字是调用本类的构造函数。

方法的重写：子父类出现了同名的函数，就称作为方法的重写。

方法重写的前提：必须存在继承的关系。

当父类的功能无法满足子类的需求时，我们就会使用方法的重写。

方法的重写要注意的事项：

1、方法重写时，方法名与形参列表必须一致。

2、方法重写时，子类的权限修饰符必须要大于或等于父类的修饰符。

3、方法重写时，子类的返回值类型必须要小于或等于父类的返回值类型。

4、方法重写时，子类抛出的异常类型要小于或等于父类抛出的异常类型。

 

方法的重载：在一个类中存在两个或两个以上的同名函数，称作为方法重载。

方法重载的要求：

1、函数名要一致。

2、形参列表不一致（形参的个数或形参的类型不一致）

3、与返回值类型无关。

Static静态修饰

      Static修饰成员变量：如果一个成员变量使用static修饰，那么该成员变量的数据就是一个共享的数据。

      静态成员变量的访问方式

                    方式一：可以使用对象访问。

                           对象.属性名

                    方式二：可以使用类名访问。

                           类名.属性名

             注：1、非静态成员变量不能使用类名直接访问，要使用对象访问。

                    2、当数据真正需要被共享是才使用static。

                    3、非静态函数只能由对象调用，静态函数可以由类名或者对象进行调用。

                    4、静态函数中不能直接访问非静态成员，可以直接访问静态的成员。

                    5、非静态函数可以直接访问非静态成员以及直接访问静态的成员。

                    6、静态函数中不能出现this或者super关键字。

单例设计模式：保证一个类在内存中只有一个对象。

饿汉单例设计模式：

1、私有化构造函数。

2、声明本类的引用类型变量并且指向本类的对象（private static）

3、提供一个公共静态的方法获取本类对象。

懒汉单例设计模式：

1、私有化构造函数。

2、声明本类的引用类型变量，但是不要创建对象。

3、提供一个公共静态的方法获取本类对象，获取之前先判断是否已经创建了本类的对象，如果没有创建，创建再返回，如果已经创建了，那么直接访问即可。

继承

继承的格式：

                    class类名1 extends 类名2{

}

继承的注意事项

1、父类私有的成员不能被继承。

2、父类的构造函数不能被继承。

3、创建子类对象时，默认会先调用父类无参的构造函数，然后再调用子类的构造函数。

super关键字的作用：

1、如果子父类存在同名的成员时，在子类中默认时访问子类的成员，可以通过super关键字指定访问父类的成员。

2、创建子类对象时，默认会先调用父类无参的构造函数，可以通过super关键字指定调用父类的构造函数。

super关键字要注意的事项：

1、如果在子类的构造函数中没有指定调用具体父类的构造函数，那么java编译器会在子类的构造函数上添加suoer（）语句。

2、super关键字调用构造函数时必须出现构造函数中第一个语句。

3、this与super调用构造函数的时候不能同时出现在一个构造函数中，因为都需要是第一个语句。

方法重写：子父类存在着同名的函数。

方法重写的需求：如果父类的功能无法满足子类的需求，那么就进行重写。

方法重写的要素：

1、函数名与形参列表必须一致。

2、子类的权限修饰符必须大于或等于父类的权限修饰符。

3、子类的返回值类型必须小于或者等于父类的返回值类型。

4、子类抛出的异常类型必须要小于或者等于父类抛出的异常类型。

instanceof：判断一个对象是否属于某种类型。

instanceof关键字的使用格式：

      对象 instanceof 类

instanceof的使用前提：判断的对象与类型必须存在继承或者实现的关系。

每个方法运行的时候，jvm都会为该方法开辟一片内存空间是属于这个方法的。方法中的形参也是属于该方法的局部变量。不同方法上面的局部变量是相互独立的，没有任何的关系。

final（最终的，修饰符）

final关键字的用法：

1、final关键字修饰一个基本类型的变量时，该变量不能重新赋值，第一次的值是最终的。

2、final关键字修饰成员变量时，一定要给变量初始值。

3、final关键字修饰一个引用类型变量时，该变量不能重新指向新的对象。

4、final关键字修饰一个函数的时候，该函数不能被重写。

5、final关键字修饰一个类的时候，该类不能被继承。

6、常量的修饰符一般为public static final 

抽向类应用场景：我们在在描述一类事物的时候，发现该种事物确实存在着某种行为，但是这种行为目前是不具体的，那么我们可以抽取这种行为的声明，但是不去实现这种行为，这时候这种行为我们称作为抽象的行为，我们就需要使用抽象类。

1、如果一个函数没有方法体，那么该函数必须要使用abstract修饰，把该函数修饰成抽象的函数。

2、如果一个类出现了抽象的函数，那么该类也必须使用abstract修饰。

3、如果一个非抽象的类继承了抽象类，必须把抽象类的所有抽象方法全部实现。

4、抽象类可以存在非抽象类方法，也可以存在抽象的方法。

5、抽象类可以不存在抽象方法。

6、抽象类不能创建对象。（因为抽象类存在抽象方法，如果让抽象类可以创建对象的话，那么使用抽象的对象调用方法是没有任何意义的。）

7、抽象类存在构造函数，构造函数是提供给子类创建对象的时候初始化父类的属性的。

抽象类的优点：强制要求子类一定要实现指定的方法。

 

常量的规范：全部字母大写，单词与单词之间使用下划线分割。

abstract不能与一下关键字共同修饰一个方法：

1、       abstract不能与private共同修饰一个方法。

2、       abstract不能与static共同修饰一个方法。

3、       abstract不能与final共同修饰一个方法。