Javase（三）

重载、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;
        }
}