1.static

       static是一个修饰符,它可以修饰类成员

修饰成员属性  ---->类属性  静态属性

                     1.使用static修饰的属性它属于这个类的所有对象所共享,它不在属性对象.

也就是说static修饰的属性不在对象的堆内存中。

                     2.static属性它是随着类的加载而加载的。

                       static修饰的属性可以理解成它属于类了，不在属于对象，那么我们使用时

就可以直接使用类名去调用，而不需要对象。

                     3.对于static 属性我们在调用时可以使用  对象调用也可以通过类名调用。

什么时候使用static修饰属性

当前属性描述的是类的相关信息而不是对象的，或者这个属性是所有对象所共享的

这个时候就可以使用static来修饰属性.

类属性与实例属性区别

                     class类名

                     {

成员属性:细划分2种类型:1.类属性(用static修饰的)2.实例属性(没有被static修饰的)

成员方法:

                     }

                     1.生命周期:实例属性的生命周期与对象相同    类属性生命周期与类相同。

                     2.内存:    实例属性在堆放内存             类属性是在方法区的静态区内。

                     3.使用:    实例属性必须通过对象(引用)调用  类属性还可以通过类名调用 。

                     4.共享:    每一个对象都有自己的实例属性    所有对象共享类属性。

修饰成员方法------->类方法(静态方法)

                     class类名

                     {

成员属性

方法:1.类方法(static)2.实例方法(没static)3.构造方法

                     }

                     1.类方法它是随关类的加载而加载.

                     2.类方法在使用时可以通过类名去调用.

▲▲▲▲▲static方法使用的注意事项:

                     1.static方法内不能使用非static成员。//错误: 无法从静态上下文中引用非静态

                     2.static方法内不能使用this super关键字

在实例方法内是否可以使用static成员

可以直接使用static成员。

              static方法什么时候使用?

                     1.如果当前static方法内没有使用实例属性，那么这个方法应该是static .

                     2.如果当前类是一个工具类，它中的方法是完成某个操作，不涉及当前类的相关操作。

在实际开发中我们操作static属性 static 方法在调用时一般都是使用  类名.类属性  类名.类方法.

              static的优点:可以节省资源

              static弊端:  生命周期长 就用时不能操作实例属性.

              class类名{

成员属性:1.类属性(static) 2.实例属性(没有用static修饰)

方法: 1.类方法(staitc) 2.实例方法(没有用static修饰) 3.构造方法

              }

类方法，实例方法，构造方法区别

格式：  类方法  使用static修饰     修饰符 static  返回值类型 方法名(参数){}

实例方法 不用static修饰    修饰符  返回值类型 方法名(参数){}

构造方法      权限修饰符  类名(参数){}

使用:   类方法    引用(对象).类方法     类名.类方法

实例方法  引用(对象).实例方法

构造方法  不能被调用  创建对象时自动被调用。

              存储空间: 类方法    方法区的静态区内

                       实例方法  方法区

                       构造方法  方法区

              应用场景: 类方法    描述与实例属性无关的操作，或工具类的方法。

                       实例方法  描述与对象有关的信息

                       构造方法  创建对象的。

            

              加载   : 类方法是随着类的加载而加载

                       实例方法：有了对象才可以使用

                      构造方法:  当创建对象时就加载 .

       main方法是静态的。

            

              public static void main(String[] args){

                     方法体

              }

              public 权限修饰符

              static 类方法

              void   没返回值.

              main   固定

              (String[] args)

              为什么main方法是静态的。

                     jvm在加载类文件时要让其执行，就可以使用类名.main就可以执行了。而不需要创建对象。

                    

                     java Demo5 abc def 解析执行时

                     Demo5.main(new String[]{"abc","def"}); jvm调用时

              调用main方法时，main这个方法有参数，这个参数有什么用户？

                     main后面的数组-----命令行参数

                    

              我们可不可以自己调用main方法哪？

                     main方法也是一个static方法，如果我们要调用也可以使用类名去调用主方法。

                    

       javadoc 生成文本文档

              它是将类中的所有的

              /**

              */

              里面的内容抽取出来形成.html文件。

              javadoc -d 路径 文件名 -version -author

              -d 将生成的.html文件装入到指定的目录

              @param 来描述参数

              @return 来描述返回值

              对于下面两个我们在进行javadoc时就需要将其做为参数传递

              @version 描述版本

              @author  描述作者

              API:application Program interface

      

       单例设计模式(重点解步骤 代码)*****

              设计模式:java中设计模式23得种.

              设计模式解决问题的方式，遵循模式去开发的代码可以让代码更安全更健壮.

              单例设计模式解决的问题

                     保证某个类的对象只有一个所有的人所使用的是同一个对象。

单例模式的步骤:

              1.构造方法私有化

                            让外部不可以直接创建本类对象

              2.在类内实例化一个本类对象 ,属性一般都会private

                            必须在内部得到一个本类对象。是可以让外部访问到的。但是属性一般都要私有化

              3.在本类内提供一个外部可以访问的获得本类对象的static方法。

                            提供一个可以被外部访问的方法，这个方法构造方法私有化了，所以要做在类方法。

--------------------------------------------------------------------------------------------------------------------------------

       单例模式什么时候使用?

              

              当前对象的创建比较消耗资源，我们在使用这个对象时只需要有一个就可以应用。

              这个时候就可以将其设计成单例的模式。

              实际操作：java连接数据库，与数据库的连接会比较消耗资源。我们可以将其做成单例的，

              这个时候在内存中就有一个，所有人操作的都是一个。

              //饿汉式(工作中用)

              /*

              单利模式:保证当前single类的对象只有一个,

                     1.构造方法私有化

              */

                     Singles1=Single.s;//等于newSingle();

                     Singles2=Single.s;//s1,s2同一个对象

              classSingle

              {

                     //因为不让外面创建对象了,那么就在在本类内创建一个对象.

                     privatestatic Single s=new Single();

                     //私有构造方法

                     privateSingle(){

                     

                     }

                     //对外提供公共的可以获得本类对象的方法.

                     publicstatic Single getInstance(){

                            returns;

                     }

              }

                     

              

              //笔试中

              //延迟加载的方式(懒汉式)  不完善，讲多线程还要对其进行改进.

              classSingle

              {

                     //在本类内创建一个对象.

                     privatestatic Single s;

                     //私有构造方法

                     privateSingle(){

                     

                     }

                     //对外提供公共的可以获得本类对象的方法.

                     publicstatic Single getInstance(){

                            if(s==null){

                                   s=newSingle();

                            }

                            returns;

                     }

              }

       static代码块

              

              static{

              

              }

特点:它是随着类的加载而加载，并且只加载一次。

              静态代码块什么时候使用?

                     1.在项目中有一些配置文件，它们需要在我们项目启动时就加载，并且只加载一次。

                       那这时候就可以将这些信息放到静态代码块中。

                     2.如果是对类的相关信息的描述，这个时候也可以将这些信息放入到静态代码块中。

------------------------------------------------------------------------------------------

class Demo9          14.程序的执行流程

{

       publicstatic void main(String[] args)

       {

              ClassDemocd=new ClassDemo();//这句话执行时，它的内部具体的过程

      

       }

}

class ClassDemo

{

       static{

      

       }

      

       {

              System.out.println("hello");

       }

      

       ClassDemo(){

              

              System.out.println("ha....");

       }

       ClassDemo(Strings){

              //System.out.println("hello");

              System.out.println("heihei...");

       }

}

/*

       javacClassDemo.java编译 产生了 .class文件

       1.jvm加载.class文件.

       2.static内容进行加载   静态代码块  静态属性  静态的方法

       3.构造代码块执行

       4.构造方法执行.

       5.在栈内开辟空间保存cd

       6.在堆放内开辟空间保存对象.对成员属性赋默认值  在去显示赋值.

       7.将堆内存的地址赋值给栈内存空间。

*/

---------------------------------------------------------------------------------

       继承(重点)

              学生类与老师类中都有共同的属性 name  age,有共同的行为eat

              这时就可以将其向上抽取产生一个父类 Person在Person类中有name,age,eat()方法。

              classPerson

              {

                     Stringname;

                     intage;

                     

                     publicvoid eat(){

                     

                     }

              }

              classTeacher extends Person

              {

                     

                     publicvoid teach(){

                     

                     }

              }

              classStudent extends Person

              {

                     

                     intsid;

                     publicvoid study(){

                            System.out.println(name+"好好学习");

                     }

              }

怎样去查看一个继承体系

              

              父类中的成员都是从子类中抽取共性的内容。

              最顶层的类标识的是当前体系中的共性的行为.

              最底层的它有特性的行为.

              我们在学习一个体系时，是从项层看起，通过顶层了解整个体系的功能。

              而使用时是使用底层，底层有特性的行为.

       继承中的构造方法

              

              构造方法不能被继承.

              我们发现当子类对象创建时，子类构造会被执行，但是父类构造优先子类构造执行了。

              为什么出现这个效果

              是因为所有构造方法中默认执行的语句 super();

              super()代表的是执行父类的无参数构造方法.

              java中的根类 Object，它代表提所有类的直接或间接父类.

              父类构造方法被执行本质是为了实例化子类对象，因为子类对象中要包含父类中的

              成员属性，这些成员属性是在父类中定义的，那么要想在子类对象中有，必须实例化

              父类对象.

              

              this([参数]) --->执行本类的构造方法.

              super([参数])--->执行父类的构造方法.

              上面的this与super的使用的注意事项

                     1.它们只能在构造方法中使用。

                     2.如果构造方法中没有this(),super(),那么默认第一句话是 super();

                     3.如果在构造方法中出现了this(),super()那么必须是构造方法中第一句.

                     4.this()与super()不能共存.

              super出现在成员方法中

                     作用是用来区分父子类中同名的成员的。

              this作用

                     作用是区分成员变量与局部变量的。

一    this关键字1.1 this关键字

              this指代对象

              this代表其所在函数所属对象的引用。

              "补充笔记"

1.2 this作用

解决重名问题

1.3 this关键字特点

this代本类对象的引用。

this:其实代表的是this所在的函数所属的对象的引用

简单讲;哪个对象在调用this所在的函数,this就代表(指向)哪个对象

在类中对成员访问必须要用成员调用的方式

只要成员被调用 必须用this调用

构造函数之间的调用:

This在构造函数中的应用 可以通过this在构造函数 中对其他构造函数进行调用

注意:在构造函数中,如果this调用

1.4 什么时候用this

当在函数内需要用到调用该函数的对象时，就用this。

当定功能时 功能内部用到了对象中的成员,这时该对象用this表示

二static关键字2.1 static关键字

static是一个修饰符,它可以修饰类成员（成员变量和成员函数）

被修饰后的成员具备以下特点：

随着类的加载而加载

优先于对象存在

被所有对象所共享

可以直接被类名调用

2.2 修饰成员属性>类属性,静态属性

                     1.使用static修饰的属性它属于这个类的所有对象所共享,它不在属性对象.

                        也就是说static修饰的属性不在对象的堆内存中。

                     2.static属性它是随着类的加载而加载的。

                       static修饰的属性可以理解成它属于类了，不在属于对象，那么我们使用时

                       就可以直接使用类名去调用，而不需要对象。

                     3.对于static 属性我们在调用时可以使用  对象调用也可以通过类名调用

                            什么时候使用static修饰属性

                                   当前属性描述的是类的相关信息而不是对象的，或者这个属性是所有对象所共享的

                                   这个时候就可以使用static来修饰属性.

2.3 修饰成员方法>类方法,静态方法

                     1.类方法它是随关类的加载而加载.

                     2.类方法在使用时可以通过类名去调用.

              static方法使用的注意事项:

                     1.static方法内不能使用非static成员。

                            错误: 无法从静态上下文中引用非静态

                     

                     2.static方法内不能使用this super关键字

              

              在实例方法内是否可以使用static成员

              可以直接使用static成员。

              static方法什么时候使用?

                     1.如果当前static方法内没有使用实例属性，那么这个方法应该是static .

                     2.如果当前类是一个工具类，它中的方法是完成某个操作，不涉及当前类的相关操作。

                     

              在实际开发中我们操作static属性 static 方法在调用时一般都是使用  类名.类属性  类名.类方法.

static使用注意

静态方法只能访问静态成员

静态方法中不可以写this，super关键字

主函数是静态的

面向对象分析问题中一定要确定领域 无关的不考虑

//new的作用在于开辟空间 开辟空间的目的是存数数据(存数对象中所涉及的数据)

当成员变量和局部变量重名时

static特点

1他是一个修饰符,用于修饰成员(成员变量和成员函数)

2 被静态修饰后的成员变量,可以被对象共享.而不存在对内存当中

3静态优先于对象存在 才能实现被所有对象共享   

4对于静态成员 除了对象可以访问之外,还可以被类名直接访问.

访问方式:类名.静态成员

5静态随着类的加载而加载,随着类的消失而消失

对象特有的数据存储到对象的对内存中

对象的共享数据存数在方法去的静态区中

                     

                            static的优点:可以节省资源

                            static弊端: 生命周期长 就用时不能操作实例属性.

static使用的注意事项

1,静态方法只能访问静态成员(所以静态虽然多了一种类名调用的方式,但是也出现了访问的局限性

非静态方法既可以访问静态又可以访问静态    因为非静态们,都所属于对象,

2,静态方法中不可以出现thissuper关键字      

因为this代表对象,static方法存在时还咩有对象呢

3,主函数是静态

类属性与实例属性区别

                     1.生命周期:实例属性的生命周期与对象相同    类属性生命周期与类相同。

                     2.内存:    实例属性在堆放内存              类属性是在方法区的静态区内。

                     3.使用:    实例属性必须通过对象(引用)调用 类属性还可以通过类名调用 。

                     4.共享:    每一个对象都有自己的实例属性    所有对象共享类属性。

       class类名{

                     

                     成员属性:1.类属性(static)  2.实例属性(没有用static修饰)

                     

                     方法: 1.类方法(staitc) 2.实例方法(没有用static修饰) 3.构造方法

              }

类方法，实例方法，构造方法区别

                     

              格式： 类方法  使用static修饰     修饰符 static  返回值类型 方法名(参数){}

                     实例方法 不用static修饰    修饰符  返回值类型 方法名(参数){}

                     构造方法      权限修饰符  类名(参数){}

              

              使用:  类方法    引用(对象).类方法     类名.类方法

                     实例方法 引用(对象).实例方法

                     构造方法 不能被调用  创建对象时自动被调用。

              存储空间: 类方法    方法区的静态区内

                       实例方法  方法区

                       构造方法  方法区

              应用场景: 类方法    描述与实例属性无关的操作，或工具类的方法。

                       实例方法  描述与对象有关的信息

                       构造方法  创建对象的。

              

              加载  : 类方法是随着类的加载而加载

                       实例方法：有了对象才可以使用

                      构造方法:  当创建对象时就加载 .

成员变量和静态变量的区别

类中定义的变量是成员变量，也称为实例(对象)变量。

如果该变量被static修饰，称静态变量，也称为类变量。

成员变量和静态变量的区别

1，在内存空间存储的位置。

成员变量存储于对象所在堆内存中

静态变量存储方法区的静态区中。

2，生命周期。

       成员变量随着所属对象的建立而出现，随着所属对象变成垃圾被回收而消失。

       静态变量虽则所属的类加载而出现，随着类的消失而消失。

3，调用方式。

       成员变量只能被对象调用。

       静态变量既可以被对象调用，也可以被类名调用。

4，数据体现。

       成员变量的值称为对象中的特有数据。

       静态变量的值称为对象中的共享数据。

static的使用场景

静态变量

当对象中的数据都相同时,就将该数据定义成静态的,

被所有对象共享即可,没有必要每一个对象都存储一份   (对对内存空间节约)

静态函数

如果函数中没有访问到对象中的特有数据

那么该函数需要被静态修饰,不需要创建对象就可以通过类名访问该函数

public:   主函数是一个功能,被JVM调用所以权限要足够大

static:     JVM调用主函数,是不需要对象的

void:      主函数没有返回值

main:     主函数固定的名称,JVM认识

(String[]args):     主函数的参数列表,就一个参数,字符串数组类型

静态代码块

特点       随着类的加载而执行,只执行一次.

作用       给类进行初始化

三 main函数的组成部分介绍main函数的组成部分介绍

public static void main(String[] args)

public                   主函数是一个功能，被jvm调用所以权限要足够大。

static                     jvm调用主函数，是不需要对象的。

void                      主函数没有返回值。

main                     主函数固定的名称的，jvm认识。

(String[] args)        主函数的参数列表，就一个参数，字符串数组类型。

              main方法是静态的

              public static void main(String[] args){

                     方法体

              }

              public 权限修饰符

              static 类方法

              void   没返回值.

              main   固定

              (String[] args)

              为什么main方法是静态的

                     jvm在加载类文件时要让其执行，就可以使用类名.main就可以执行了。而不需要创建对象。     

                     java Demo5 abc def 解析执行时

                     Demo5.main(new String[]{"abc","def"}); jvm调用时

              调用main方法时，main这个方法有参数，这个参数有什么用户

                     main后面的数组-----命令行参数

                    

              我们可不可以自己调用main方法

                     main方法也是一个static方法，如果我们要调用也可以使用类名去调用主方法。

12-面向对象(静态代码块)

静态代码块。

特点

随着类的加载而执行，只执行一次。

作用

给类进行初始化。

13-面向对象(Java的文档注释使用)

javadoc 生成文本文档

              它是将类中的所有的

              /**

              */

              里面的内容抽取出来形成.html文件。

              javadoc -d 路径 文件名 -version -author

              -d 将生成的.html文件装入到指定的目录

              @param 来描述参数

              @return 来描述返回值

              对于下面两个我们在进行javadoc时就需要将其做为参数传递

              @version 描述版本

              @author  描述作者

              API:application Program interface

学习一下，感谢分享！