Static那些事儿

Static关键字

被static修饰的变量成为静态变量（类变量）

作用：是一个修饰符，用于修饰成员（成员变量，成员方法）

1、被static修饰后的成员变量只有一份

2、当成员被static修饰之后，多了一种访问方式，除了可以被对象调用之外还可以被雷鸣直接调用（类名.静态成员）

static关键字，修饰变量，只保存最后一个值，立即改，立即用。

static关键字是一个修饰符说白了意思就是用static修饰成员以后，这个成员就变成大家共有的了 ，任意一个对象可以调用它并且也可以修改它的值 比如static String name= 王二， 那么这个name类变量 本类中所有对象都可以调用它，也可以修改它

Static的特点：

1、随着类的加载而被加载

2、优先与对象的存在

3、被所有的对象所共享的

4、可以直接被类名所调用

存放位置：

类变量是随着类的加载而存在于data内存区

实例变量随着对象的建立而村子啊与堆内存

生命周期:

1、类变量生命周期最长，随着类的消失而消失

2、实例变量生命周期比类变量

静态方法注意事项：

1、静态的方法只能防卫静态的成员

2、非静态的方法既能访问静态的成员（成员变量，成员方法）也能防卫非静态的成员

3、静态的方法中事不可以定义this super关键字的，因为惊天优先于对象存在，所以静态方法不可以出现this,局部变量事不能被statit修饰的

什么时候使用静态：

Static所修饰的内容是成员（成员变量，成员方法）

从两方面入手：

什么时候使用静态的成员变量：

当属于同一个类的所以对象出现共享数据时，需要将存储这个共享数据的成员变量用static修饰

什么时候使用静态方法：

当功能内部没有访问到非静态的成员时（对象特有的数据），该功能可以定义成静态的

主函数（主方法）==36

静态工具类==39

每个应用程序都有共性的功能，可以将这些功能进行抽取，独立封装，以使服用

对象的作用：对象是用来封装数据的，只要这个类里面有静态的成员时，那对象就必须存在。

Classpath==40

path:主要功能是设置JDK的可执行命令

classpath：主要是在执行的时候起作用，告诉JVM（java虚拟机）的所保存的路径

也可以在环境中设置

Java文档注释  文档标识符==41

 

用文档注释来建立文档说明

Java自动提供了一个文档说明的提取器 javadoc

利用文档标识符进行注释说明

/**

这里写说明

*/

@param 后边跟上具体的参数名和注释解释说明

@return

@author 作者

@version 版本

以上这些写好之后如何提取？

提取步骤：

1. 打开cmd,进入到java文件的所在目录中
2. 输入javadoc
3. 

如果要提取这个类，就要保证这个类是public公共的

3、执行命令后

4、打开一个html(建议打开index.html)

静态代码块==42

静态代码块==42

格式：

static{

静态代码块中执行语句

}

特点：随着类的加载而执行，并且只会执行一次，并且还优先于主函数

作用：用于给类进行初始化

对象初始化话过程 == 43

java的内存被分成了几个区：堆 栈 方法区

1、因为new Student()用到了Student类，所以会把它从硬盘上加载进入内存

2、如果有static静态代码块就会随着类的加载而执行，还有惊天成员和普通该方法也会随着类的加载而被执行

3、在堆中开辟空间，分配内存地址

4、在堆中建立对象特有属性（非静态属性），并同时对特有属性进行默认初始化

5、对属性进行显示初始化

6、执行构造代码块，对所以对象进行初始化

7、执行对应的构造函数，对对象进行初始化

8、将内存地址给S（给栈中的变量）

设计模式==44

设计模式：起源于建筑，在盖房子中发现有些可寻的规律，然后为了提高盖房子的效率，把这些可寻的规律总结起来，就形成了模式。==后来用在了软件当中

软件中设计模式：针对此类问题最有效的解决方法

Java中一共有23中设计模式====书《设计模式》——是面向思想的，因此理解思想而不是单纯的记录代码

单例设计模式:解决一个类只在内存中存在一个对象

如何让一个类在内存中只存在一个对象？

1、禁止其他的应用程序，通过此类来创建对象

2、既然外部不能通过此类创建对象了，我们要用对象，就可以在本类雷曼创建本类对象。

3、为了其他应用程序能够访问到本类里面创建的对象，我需要对外界提供一种访问方式

如何用代码提现出来：

1、私有化构造方法

2、在本类中创建本类对象

3、得对外界提供访问的方法

继承==45==46

类就是描述现实生活中的事物（分类），而对象才是具体的东西

继承的概述：

1、提高代码复用性，简化代码

2、让类与类之间产生了继承关系，才有后面的多态性的存在

注意：千万不要为了活去其他类的功能简化代码，而建立继承关系

必须要类与类支架存在继承关系，继承关系 is A(谁要是谁)

子类拥有父类的成员，子类不能拥有父类中被private修饰后的成员

Java多层继承 在多层继承中最下层的子类拥有整个继承体系的成员，最上层的父类里面定义所有子类的共性描述

Java中不支持多继承，只支持单继承，因为多继承存在安全隐患，当多个弗雷定义了相同的成员，当子类对象不确定运行哪一个。

Java保留这种机制，并用了另一种方式来体现多实现（接口）

父类是将共同的特性抽取出来组成的

子父类中的成员变量==47

子父类成员特点：

成员：

1、成员变量

2、函数

3、构造函数

1、变量：

this         代表当前对象的引用

this.变量     首先在本类中找所需要的这个变量，如果没有找到再在父类中找

super        用于访问当前对象的父类成员，

super.变量    直接在父类中找所需变量

（super() 函数是用于调用父类(超类)的一个方法。 super 是用来解决多重继承问题的,）

子父类中的函数==48

当子类中出现和父类中一样的函数时，当子类对象调用该函数，

运行的是子类中的函数，如同父类中的函数被覆盖了一样，

这种情况就是函数的另一种特性：重写（覆盖）

注意：

1、子类方法覆盖父类时，必须要保证子类方法权限大于等于父类，才可以覆盖，否则编程出错

访问权限修饰符：public > default > private  成员前面没有加任何访问权限，修饰符默认权限就是default

2、静态的函数只能覆盖静态的

记住：

重载：只看同名的方法的参数列表

重写：子父类中方法要一模一样

继承中的构造函数==49

有了子父类之后构造函数的特点：

在对子类对象进行初始化的时候，父类的构造方法也会运行，那时因为子类的构造函数默认第一行有一条隐式的语句 super();

子类每个构造方法第一行都有一个隐式的 super();

对象转型==50

对象的转型：

1、对象的向上转型  子类转成父类 默认进行 父类引用指向子类对象

2、对象的向下转型  父类转成子类  必须强制转型

关键字：instanceof  测试左边的对象是否是右边类的实例

多态的概述==51

多态：可以理解为事物存在的多种体现形态

动物：猫 狗 猪

人 男人 女人

1、多态的体现

是父类引用指向子类对象

2、多态的前提

（1）必须得类于类之间存在关系，可以是继承关系 也可以是实现关系（接口中的）

（2）必须得有重写

3、多态的好处

大大提高了程序的可扩展性

4、多态的弊端

提高了程序的可扩展性，但是只能用父类的引用，访问到父类中的成员

多态成员变量的特点：

1、编译期间：参阅的是引用型变量所属的类中是否有调用的方法

2、运行期间：参阅对象所属的类中是否有调用的方法

匿名对象===54

匿名对象：没有名字的对象

匿名对象的使用方法之一：当对对象的方法之调用一次时，我们可以用匿名对象来完成，比较简化

匿名对象的使用方法之二：匿名对象可以被当做实参传递

Object类toString()===55

一个特殊的类

Object:它是Java中所有对象的直接或间接的父类，根父类（基类），它里面定义的功能是所有对象都应该具备的

记住：当定义一个新类型时，没有指明要继承某类，它默认继承Object类（这些类要在Java的API中的java.lang包中）

toString()转成字符串

Object类equals()===56

指示其他某个对象是否与此对象“相等”

和==符号其实比较的两对象的内存地址是否一

 

final关键字==57

final（最终）是一个修饰符

1、final可以修饰类、函数、变量（成员变量，局部变量）

2、被final修饰后的类不可以被其他类继承

3、被final修饰后的函数不可以被重写

4、被final修饰后的变量不允许被再次赋值，final在对变量进行修饰时一定要赋值，被final修饰后的变量我们称它常量

5、被public final static多个修饰符修饰的变量称为全局常量

注意：常量的命名规范：字母全部要大写，如果这个名字是由多个单词组成，就在单词之间用_隔开

抽象类==58==59

abstract：是一个修饰符

可以修饰方法、类

1、当我们多个类存在相同的功能，但是功能的主体不同，这时我进行向上抽取只能抽取功能的定义不抽取功能的主体

抽象类的特点：

1、抽象方法一定在抽象类中

2、抽象类和抽象方法必须要被abstract关键字修饰

3、抽象的类是不能被创建对象的，因为调用抽象的方法没有意义

4、抽象类中的方法要被使用，必须有子类重写抽象类中的方法，然后创建子类对象来调用

5、抽象类中可以定义非抽象的方法，有时我们需要此类不能被new关键字创建对象时，可以用abstract将此类变成抽象类

6、子类如果只重写一部分的抽象方法，那么盖子类还是一个抽象类，若果抽象类的方法要被使用，子类必须重写抽象类中的所有方法

值得注意：抽象类和普通类没有太大区别

1、抽象类无法通过new关键字创建对象

2、抽象类里面可以有抽象的方法

3、

模板方法设计模式==60

什么是模板方法设计模式？

定义功能时，功能的一部分是确定，而确定的部分在使用不确定，那么这时就得将不确定的部分暴露出来，由该子类去完成。

接口==61==62==63

接口：初步理解接口是一个特殊的抽象类，当抽象类张全部是抽象方法时，可以通过接口的形式来体现。

Class 用于定义类

Interface 用于定义接口

接口张成员的格式

1、public static final String NAME=”小李”;//全局常量

2、Public abstract void show();//抽象方法

注意：

1、接口中只能出现public 访问修饰符

2、接口不可以创建对象，因为里面有抽象方法，需要被子类实现，子类对接口中的所有抽象方法实现后，子类才能够实例化，否则于类就是一个抽象类

只有类与接口之间才存在实现

Java不支持多继承，因为存在安全隐患，当父类中定义了相同功能，功能内容不同时，子类不确定要运行哪一个

但是java保留了这种机制，并用另一种体现形式来完成表示===多实现

关系：

类与类之间：继承关系

接口与类之间：实现关系

接口与接口之间：继承关系

如何实现一个接口

如何多实现接口

接口：提高了我们功能的扩展性，因为它降低事物与事物之间的耦合性（关系紧密程度）

父类中定义的是多个类*性的基本功能，接口中定义的是扩展功能

接口好处：

1、可以多实现，也就是一个类可以实现多个接口

包机制==64

包（package）

什么是包？可以理解为文件夹

包的作用：

1、对类进行分类管理

2、给类提供了多成命名空间

注意：

1、类名的全程是包名.类型

命名规范：包全小写

2、定义包的语句一定要在代码的第一行

package pack;

包与包之间的访问及访问权限==65

jar包==66

jar包  就是java里的一个压缩包

做项目时顺序应该是先建一个文件夹然后包在包里面建立类等

然后在编译就可以了