JAVA复习 面向对象高级编程Day11 代码块重难点

JAVA复习Day11 简单练习加简单项目继续放在Day10

面向对象高级编程

10.1类变量

10.1.1类变量(静态变量)的基本入门

public static int count =0;//静态变量

该变量最大的特点就是会被类（）的所有的对象实例共享

10.1.2类变量的内存布局

静态变量就是自己单独有一个空间去存放这个数据，放在堆空间（在此处也可能是方法区/版本问题所影响的）
不管static变量在哪里，static变量是同一个类所有对象共享的
static变量是在类加载的时候就生成

10.1.3类变量定义及访问

类变量：是该类所有对象共享的变量，任何一个该类的对象区访问它时，取到的都是相同的值，同样任何一个该类的对象区修改它时，修改的也是同一个变量
定义类变量
访问修饰符 static 数据类型 变量名；
static 访问修饰符 数据类型 变量名；

访问类变量
类名.类变量名 或者 对象名.类变量名
静态变量的访问修饰符的访问权限和范围和普通属性是一样的

###############################################################
类变量是随着类加载而创建的，即使没有创建对象实例也可以访问
###############################################################

10.1.4类变量的注意事项及细节

1什么时候需要类变量？
当需要让某个类的所有对象都共享一个变量时，就可以考虑使用类变量

2类变量与实例变量(实例变量)的区别？
类变量是该类的所有对象共享的，而实例变量是每个对象独享的

3加上static称为类变量或者静态变量，否则未实例变量

4类名.类变量名 或者 对象名.类变量名 推荐：类名.类变量名

5实例变量不能通过类名.类变量名方式访问

6类变量是在类加载时就初始化了，就是说，即使你没有创建对象，只要类加载了，就可以使用类变量了

7类变量的生命周期是随着类的加载开始，随着类消亡而销毁

10.1.5类方法的快速入门

类方法也叫做静态方法

形式：
访问修饰符 static 数据返回类型 方法名（）{}
static 访问修饰符 数据返回类型 方法名（）{}

类方法的调用
使用方式：类名.类方法名或者对象名.类方法名

静态方法可以访问静态属性

10.1.6类方法使用场景

方法中不涉及到任何和对象相关的成员，则可以将方法设计成静态方法，提高开发效率

10.1.7类方法的使用细节

1类方法和普通方法都是随着类的加载而加载，将结构信息存储在方法区：
类方法中无this的参数

2类方法可以通过类名调用，也可以通过对象名调用

3 普通方法和对象有关，需要通过对象名调用，不能通过类名来调用

4类方法中不允许使用和对象有关的关键字，super，this

5类方法中只能访问静态变量和静态方法

6 普通成员方法，既可以访问普通方法，也可以访问静态变量方法

10.2main方法

10.2.1main方法的语法

1、main方法是java虚拟机来调用的，所以该方法的访问权限必须是public
2、java虚拟机在执行main方法时不必创建对象，所以该方法必须时static
3、该方法接收String类型的数组参数，该数组中保存执行java命令时传递给所允许的类的参数，接收参数
4、java 执行的程序 参数1 参数2 参数3

 public static void main(String[] args) {
//参数就是在执行的时候给传进去的
//如下图
    }

如果想要再IDEA中传入参数，那么以下为参考步骤

10.2.2main方法的特说明

main方法可以访问本类的静态成员
main不可以访问本类的非静态成员
mian要访问本类的非静态成员，需要创建对象，再调用即可

10.3代码块

10.3.1代码块

代码块又称为初始化块，属于类中的成员，类似于方法，将逻辑语句封装在方法体中，通过{ }包围起
来
和方法的区别
没有方法名，没有返回，没有参数，只有方法体，而且不用通过对象或类显示调用，而是加载类时，或创建对象时隐式调用

10.3.2代码块的基本语法

【修饰符】{
代码
}；
修饰符是可选的，要写的话，也只能写static
代码块分为两类，使用static修饰的叫静态代码块，没有static修饰的，叫普通代码块
逻辑语句可以为任意的逻辑语句
；可以写上，也可以省略

10.3.3代码块的好处

相当于另外一种形式的构造器(对构造器的补充机制)，可以进行初始化操作
如果多个构造器中都有重复语句，可以抽取到初始化块中，提高代码的重用性

class movie{
    private  String name;
    private  double price;
    private  String director;
    //三个构造器  重载
    //这样的话代码比较冗余
    //引入代码块
    public movie(String name, double price, String director) {
        System.out.println("电影屏幕打开...");
        System.out.println("广告开始...");
        System.out.println("电影正式开始...");
        this.name = name;
        this.price = price;
        this.director = director;
    }

    public movie(String name, double price) {
        System.out.println("电影屏幕打开...");
        System.out.println("广告开始...");
        System.out.println("电影正式开始...");
        this.name = name;
        this.price = price;
    }

    public movie(String name) {
        System.out.println("电影屏幕打开...");
        System.out.println("广告开始...");
        System.out.println("电影正式开始...");
        this.name = name;
    }
}

下面是引用代码块的代码

public class block {
    public static void main(String[] args) {
        movie movies = new movie("无名");

    }
}
class movie{
    private  String name;
    private  double price;
    private  String director;
    //三个构造器  重载
    //这样的话代码比较冗余
    //引入代码块

    {
        System.out.println("电影屏幕打开...");
        System.out.println("广告开始...");
        System.out.println("电影正式开始...");
    }

    public movie(String name, double price, String director) {
        this.name = name;
        this.price = price;
        this.director = director;
    }

    public movie(String name, double price) {

        this.name = name;
        this.price = price;
    }

    public movie(String name) {
        System.out.println("构造器能够被调用...");
        this.name = name;
    }
}

! 程序运行截图

10.3.4代码块的注意事项

1、static 代码块也叫做静态代码块，作用就是对类进行初始化，而且它随着类的加载而执行，并且只会执行一次，如果是普通代码块，每创建一个对象，就执行

2、类在什么时候被加载
A：创建对象实例时
B：创建子类对象实例，父类也会被加载
C:使用类的静态成员时

3、普通的代码块，在创建对象实例时，会被隐式的调用，被创建一次，就会调用一次
如果只是使用类的静态成员时，普通代码块不会被执行

4、创建一个对象时，在一个类调用顺序时（重点，难点）
A：调用静态代码块和静态属性初始化（静态代码块和静态属性初始化调用的优先级一样，如果有多个静态代码和多个静态变量初始化，则按照他们定义顺序调用）

package com.charpter10.exe1;

public class block {
    public static void main(String[] args) {
        A a = new A();

    }
}
class A{
    private static  int n1=getN1();//看调用顺序不一致

    static{
        System.out.println("A静态代码块01");
    }//静态代码块
    public static int getN1(){
        System.out.println("getN1被调用...");
        return 100;
    }
}

! 程序运行图

package com.charpter10.exe1;

public class block {
    public static void main(String[] args) {
        A a = new A();

    }
}
class A{
    static{
        System.out.println("A静态代码块01");
    }//静态代码块
    private static  int n1=getN1();
    public static int getN1(){
        System.out.println("getN1被调用...");
        return 100;
    }
}

! 程序运行图

B:调用普通代码块和普通属性的初始化（普通代码块和普通属性初始化调用的优先级一样，如果有多个普通代码块和多个普通属性初始化，则按定义顺序调用）

package com.charpter10.exe1;

public class block {
    public static void main(String[] args) {
        A a = new A();
    }
}
class A{
    
    private   int n2=getN2();
    {//普通代码块
        System.out.println("B普通代码块01");
    }
    static{//静态代码块
        System.out.println("A静态代码块01");
    }
    private static  int n1=getN1();
    public static int getN1(){//静态方法
        System.out.println("getN1被调用...");
        return 100;
    }
    public  int getN2(){
        System.out.println("getN2被调用...");
        return 200;
    }
}

! 程序结果运行图

在这里就能明显看出，首先不论静态代码块和静态属性在哪，都会先进行静态的初始化，按照顺序进行静态的初始化，然后再进行普通的代码块
C:再调用构造方法

package com.charpter10.exe1;

public class block {
    public static void main(String[] args) {
        A a = new A();
    }
}
class A{
    public A() {
        System.out.println("无参构造器的调用");
    }//这里将无参构造器放在最前面，然后进行运行
    private   int n2=getN2();
    {//普通代码块
        System.out.println("B普通代码块01");
    }
    static{//静态代码块
        System.out.println("A静态代码块01");
    }
    private static  int n1=getN1();
    public static int getN1(){//静态方法
        System.out.println("getN1被调用...");
        return 100;
    }
    public  int getN2(){
        System.out.println("getN2被调用...");
        return 200;
    }
}

! 程序运行图
###############################################################
总结：先静态的代码块和静态属性，然后再普通的代码块和属性，最后才是构造方法
注：这里时创建对象的时候，在一个类的调用顺序，自己进行隐式调用的
###############################################################

5构造器的最前面其实隐含了super()和调用普通代码块，新写一个类演示，静态相关代码块、属性初始化，在类加载时，就执行完毕
其实就相当于：
public B() {
super();//在这里会去到父类，进行父类的构造
调用普通代码块和普通属性的初始化
System.out.println(“B无参构造器的调用”);
}

package com.charpter10.exe1;

public class block {
    public static void main(String[] args) {
        B a = new B();
    }
}
//在这样的时候，首先就是执行A的静态代码块，静态方法;是B的静态代码块，静态方法
//然后是A类的普通代码块，普通属性初始化;A构造器
//最后才是B类的普通代码块和普通属性初始化,B类的构造器
class A{
    public A() {
        System.out.println("A无参构造器的调用");
    }
    private   int n2=getN2();
    {//普通代码块
        System.out.println("A普通代码块02");
    }
    static{//静态代码块
        System.out.println("A静态代码块01");
    }
    private static  int n1=getN1();
    public static int getN1(){//静态方法
        System.out.println("getN1被调用...");
        return 100;
    }
    public  int getN2(){
        System.out.println("getN2被调用...");
        return 200;
    }
}

package com.charpter10.exe1;

public class B extends  A {
    {//普通代码块
        System.out.println("B的普通代码块被执行");
    }
    private static  int n1=getB1();
    static {//静态代码块
        System.out.println("B的静态代码块被执行");
    }
    public static int getB1(){
        System.out.println("B的静态方法被执行");
        return 300;
    }
    public B() {
        System.out.println("B无参构造器的调用");
    }
}

6、创建一个子类时，他们的静态代码块，静态属性初始化，普通代码块，普通属性初始化，构造方法的调用顺序
这里的例子就是上面的代码和运行结果图

###############################################################
首先事父类的静态代码块和静态属性
子类的静态代码块和静态属性
父类的普通代码和普通属性初始化
父类的构造方法 ——————————————重点！！！！
子类的普通代码块和普通属性初始化
子类的构造方法
###############################################################

7、静态代码块只能直接调用静态成员（静态属性和静态方法）,普通代码块可以调用任意成员

10.4单例设计模式

10.4.1设计模式

设计模式是在大量的实践中总结和理论化之后优选的代码结构，编程风格，以及解决问题的思考模式

10.4.2单例模式

就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法
模式分为两种：饿汉式 懒汉式
饿汉式步骤 太着急，有可能还没有用到，就创建了
饿汉式可能造成创建了对象，但是没有使用
构造器私有化；目的防止直接new
类的内部创建对象
向外暴露一个静态的公共方法
未创建对象的时候就加载了，只要加载类就创建了这样的一个对象

package com.charpter10.girlfriend;

public class model {
    public static void main(String[] args) {
        girlfriend instance1 = girlfriend.getInstance();
        System.out.println(instance1);
        girlfriend instance2=girlfriend.getInstance();
        System.out.println(instance1);
    }

}
class girlfriend{
    private  String name;
    //首先将构造器私有化
    //在类的内部直接创建
    //提供一个公共方法的ststic方法，返回gf
    //为了能够在静态方法中，返回gf对象，需要将其修饰为static
    private  static girlfriend gf=new girlfriend("小红");//在类的内部直接创建
    private girlfriend(String name){
        this.name=name;
    }//首先将构造器私有化
    public static  girlfriend getInstance(){
        return  gf;
    }
    public String toString() {
        return "girlfriend{" +
                "name='" + name + '\'' +
                '}';
    }
}

懒汉式 不去用就不进行创建
**

package com.charpter10.single;
public class single01 {
    public static void main(String[] args) {
        System.out.println(cat.n1);//静态属性
        cat instance = cat.getInstance();//调用静态方法
        System.out.println(instance);//输出信息
        cat instance1 = cat.getInstance();//再一次调用静态方法
        System.out.println(instance);
    }
}
class cat{
    private  String name;
    private static  cat cat1;
    public  static  int n1=999;
    //将构造器进行私有化
    //定义一个静态属性对象
    //提供一个公共的public的static的方法，可以返回一个cat对象
    //只有当用户调用公共的方法后才进行创建一个对象，当再次调用的时候，返回上次的对象
    private cat(String name) {
        System.out.println("构造器被调用...");
        this.name = name;
    }
    public static  cat getInstance(){
        if (cat1==null){//如果没有创建一个cat对象
            cat1=new cat("小包");
        }
        return  cat1;
    }
    public String toString() {
        return "cat{" +
                "name='" + name + '\'' +
                '}';
    }
}

10.4.3两个模式的区别

1、两者最主要的区别就是创建对象的时机不同
2、饿汉式不存在线程安全问题，懒汉式存在线程安全问题
3、饿汉式存在浪费资源的可能，因为如果程序员一个对象实例都没有使用，那么饿汉式创建的对象就浪费了，懒汉式在使用时才进行创建
4、java.lang.Runtime就是经典的单例模式

10.5final关键字

10.5.1基本介绍

final可以修饰类，方法，属性和局部变量
在某些其情况下，可能会有如下需求就会使用到final
1、当不希望类被继承时，可以用final类
2、当不希望父类的某个方法被子类覆盖/重写时，可以用final关键字修饰
3、当不希望类的某个属性的值被修改，可以用final修饰
4、当不希望某个局部变量被修改，可以使用final修饰

10.5.2final的注意事项和注意细节

常量必须赋初值
1、final修饰的属性又叫做常量
2、final修饰的属性在定义时，必须赋初值，并且以后不能再修改，赋值可以再如下位置之一
定义时，在构造器中，在代码块中
3、如果final修饰的属性是静态的，则初始化的位置只能是
定义时，在静态代码块中，不能再构造器中赋值
4、final类不能继承，但是可以实现实例化对象
5、如果类不是final类，但是含有final方法，则该方法虽然不能重写，但是可以被继承
6、如果一个类已经是final类了，就没有必要再将方法修饰成final方法
7、final 不能修饰构造方法
8、final和static搭配使用，效率更高，不会导致类加载，底层编译器做了优化

package com.charpter10.final01;

public class final01 {
    public static void main(String[] args) {
            System.out.println(C.n1);
    }
}
class  C{
    public  static  final  int n1=1000;//联合使用
    static{
        System.out.println("静态代码块被加载");
    }//进行输出

}

package com.charpter10.final01;

public class final01 {
    public static void main(String[] args) {
            System.out.println(C.n1);
    }
}
class  C{
    public  static int n1=1000;
    static{
        System.out.println("静态代码块被加载");
    }
}

! 程序运行结果图
//上面两个程序就是一个有final一个没有final修饰，这样的区别就是类不会被加载

9、包装类（Integer,Double,Float,Boolean等都是final）,String也是final类

10.6抽象类

10.6.1抽象类的引入以及要解决的问题

父类方法不确定性的问题
考虑将该方法设计为抽象方法
所谓抽象方法就是没有实现的方法
这里是说没有实现，但是可以有方法体，接口中就没有方法体
当一个类中存在抽象方法时，需要将该类声明为abstract类
一般来说抽象类会被继承，会被子类来实现抽象方法

10.6.2抽象类的介绍

1、用abstract关键字来修饰一个类时，就叫抽象类
2、用abstract关键字来修饰一个方法，这个方法就是抽象方法
3、抽象类的价值更多作用在于设计，然后让子类去进行实现

10.6.2抽象类的细节

1、抽象类不能被实例化
2、抽象类不一定要包含abstract方法，抽象类可以没有abstract方法
3、一旦类包含了abstract方法，则这个类必须声明为abstract
4、abstract只能修饰类和方法，不能修饰属性和其他的
5、抽象类可以有任意的成员，因为它的本质还是一个类
6、抽象方法不能有主体，即不能实现
7、如果一个类继承了抽象类，则它必须实现抽象类的所有抽象方法，除非它自己也声明为abstract类
8、抽象方法不能使用private 、final、static来修饰，因为这些关键字都是和重写相违背的

10.6.3抽象类最佳实践——模板设计模式

就是如上的应用

10.7接口

10.7.1接口简单介绍(明天继续）