Javase（三）

骑猪看日落 2023-10-13 19:02 12阅读 0赞

### 重载、this关键字、构造器、static、final、封装、单例模式 ###

#### 01 重载 ####

*  概念：在同一个类中，方法的名字一样的方法
 *  特点：
    
     *  参数数量不同
     *  参数的数据类型不一致
     *  参数的数据类型顺序不同

#### 02 this关键字 ####

*  使用范围：this只能在类对象中的方法内使用

*  原理分析：类的对象属性相互独立，数据隔离，但是方法是数据共享的，为了区分数据使用this（this可以隐藏）
 *  示例：假设有类Student（name属性，study方法），创建两个Student对象，分别调用study方法，最后打印的名字是不一样的。

public class Student {
        public String name;
        public void study() {
        System.out.println(this.name + "好好学习!!");
     }
        public static void main(String[] args) {
            Student student1 = new Student();
            student1.name = "张三";
            Student student2 = new Student();
            student2.name = "李四";
        // 执行的都是打印【this.name + "好好学习!!"】，但是获取的name值不一样
        student1.study(); // 张三好好学习!!
        student2.study(); // 李四好好学习!!
     }
    }

#### 03 构造器 ####

*  用途：初始化类的对象

*  特点：使用new的时候相当于自动调用了类的构造器方法（本质上还是类的方法)

*  构造器的语法：
    
     *  没有返回值，没有void
     *  构造器的方法名必须和类型一致
     *  在方法中要定义要初始的参数列表（非必须）

// 默认构造器
    权限修饰符 类名() {
             
            }
    // 有参构造器
            权限修饰符 类名(数据类型 参数) {
             
            }

#### 注意： ####

*  如果自己定义了一个有参构造器，那么系统默认的无参构造器就会失效，必须重新写一个无参构造器
 *  可以通过this()来调用同一个类的构造器，this()必须在第一行

public class Dog extends Animal {
        int age;
        public Dog(){
            System.out.println("狗狗");
        }
        public Dog(String name){
            this();//狗狗
            System.out.println("狗");
        }
        public Dog(String name,int age){
            this("狗");//狗
            System.out.println("狗");
        }
    }

*  在构造器中通过this（）调用其他构造器，不会创建新的对象，只初始化属性的值

#### 04 static关键字 ####

*  用途：修饰词，一般用来修饰成员变量或函数
 *  特点：将被修饰的，变为类的公共属性
 *  优点：可以通过类名直接访问

*  修饰类的属性（成员变量）

public class Student {
        public String name;
        public static String sex;
        public static void main(String[] args) {
            Student student1 = new Student();
            student1.name = "张三";
            student1.sex = "男";
            Student student2 = new Student();
            student2.name = "李四";
            student2.sex = "女";
            // 获取的name不一样，因为name属性是普通的成员变量，属于对象，每个对象都有自己的name数据
            System.out.println(student1.name); // 张三
            System.out.println(student2.name); // 李四
            // 获取的sex不一样，因为sex属性是static修饰的成员变量，属于类，所有的对象共用，所以一次修改，全部改变
            System.out.println(student1.sex); // 女
            System.out.println(student2.sex); // 女
            // staitc修饰的成员变量可以直接通过【类名.属性名】获取
            System.out.println(Student.sex); // 女
            System.out.println(Student.name);// 编译报错
        }
    }

*  被static修饰的，可以不创建对象直接使用

*  修饰方法（同修饰成员变量）

public class Student {
            public void study() {
            System.out.println("好好学习!!");
    }
            public static void coding() {
            System.out.println("摩擦键盘!!");
    }
            public static void main(String[] args) {
            Student student = new Student();
            // 对象可以正常调用static修饰的方法和非static修饰的方法
            student.coding(); // 可以运行
            student.study(); // 可以运行
       
            // static修饰的方法还可以直接通过【类名.方法名】调用
            Student.coding(); // 可以运行
            Student.study(); // 编译报错
        }
    }

#### 注意： ####

*  静态方法只能访问静态成员（类的公共方法只能调用类的公共属性）

*  静态方法中不可以使用this或者super关键字
 *  Student.class加载到方法区的时候，系统会自动把Student所有的静态属性和方法分配到静态区（所以类的静态成员先于对象和main方法产生，再程序编译完成时就加载好了）

##### 静态代码块（补充） #####

class A {
        // 静态代码块
              static {
       
        }
    }

*  static静态代码块只在类加载时执行一次，经常用于初始化资源。
 *  静态代码块在main之前执行。

#### 05 final关键字 ####

*  用途：修饰词，可以被用来修饰类，变量以及成员方法
 *  特点：final是【最终】的意思，被修饰的对象初始化后无法再修改
 *  优点：锁死属性，变为常量不可修改
 *  修饰变量

*  被final修饰的类的属性（成员变量），一定要被赋初始值

public class Student {
                public String name;
                public final int a = 10;
                // 必须赋初始值或者可以在构造函数赋初始值，否则会编译错误
    }
    public class Student {
                public String name;
                public final int a; 
                // 必须赋初始值或者可以在构造函数赋初始值，否则会编译错误
                public Student() {
                this.a = 10;
                } 
    }

*  修饰main方法中的属性（局部变量）

*  被final修饰的变量，又被称为自定义常量。常量的意思是不会被改变的量。所以，被final修饰的变量即自定义常量是不能被改变的（只能被赋值一次，后续不能更改）

*  修饰成员方法
    
     *  当final关键字修饰了成员方法，则意味着这个方法不能被重写，但是可以被继承。

// 学生类
    public class Student {
            public String name;
            public final void study() {
            System.out.println("好好学习！！");
        }
    }
    // 小学生类
    public class Pupil extends Student{
        // 编译报错，study是final修饰的，不能被重写
              public void study() {
        }
         public void study() {
                super()//正常继承
                }
    }

*  修饰类
    
     *  当final关键字修饰一个类，则该类会成为最终类，即该类不能被继承

// final修饰学生类
    public final class Student {
    }
    // 不能继承final类，编译报错
    public class Pupil extends Student{
    }

#### 06 单例模式 ####

*  单例模式是一种常用的软件设计模式
 *  用途：windows资源管理器，java数据库中的连接池，网站的计数器

*  优点：保证系统中一个类只有一个实例

*  步骤：
    
     *  私有化构造参数
     *  定义一个类方法用于获取单例的对象
     *  在类中提供一个这个类类型的类属性（要用static修饰）
     *  在类方法中返回实例化对象

/**
     * 懒汉式单例
     */
    public class Singleton {
            private static Singleton singleton;
            private Singleton() {
        }
            public static Singleton getSingleton() {
                if(singleton == null) {
                    singleton = new Singleton();
            }
                return singleton;
        }
    }
    /**
     * 饿汉式单例
     */
    public class Singleton2 {
        private static Singleton2 singleton = new Singleton2();
        private Singleton2() {
            }
    public static Singleton2 getSingleton() {
            return singleton;
            }
    }