重载,this,构造器,static,final,封装,单例模式

重点
- this关键字,构造器,static,封装,单例模式
2. 难点
- static的理解
- 单例模式的封装过程

1. 重载

(当一个类里面有很多类似的功能,这时候就会迎来一个问题,就是我们的取名,取名很困难,并且使我们的代码的可阅读性减低)

定义:在同一个类中,方法的名字一样,参数列表不一样(包括参数类型)的两个方法是重载的,跟返回值没有关系;

目的:为了节约方法的功能命名和提高代码的可阅读性;

1. 参数数量

	add(int a,int b,int c);

2. 参数的数据类型

add(int ,int );
add(int ,double);

3. 参数的数据类型的顺序

add(int ,float);
add(float ,int );

示例:

public static void main(String args){
	//都是调用test方法,根据传参匹配对应的方法
	test();
	test(10);
	test(10,20);
	test(10,"20");
	test("10",20);

}

2.this关键字

this关键字指向的是对象本身(当前函数调用者本身);

this只能在对象的方法内使用;
即对象调用函数,程序运行时会跳转到对象相应的那个类的函数,并且会传入一个this代表对本身,所以在这个函数里面就有一个this可以用了,这个this与对象等价,可以使用对象的一切属性与方法.

public class Person {  
  
  
    public String name;  
  
    public int age;  
  
    //静态函数  
    public static  void eat()  
    {  
        System.out.println("需要吃饭");  
        //如果在这里调用walk(),那么程序会报错.因为一个是static函数,一个是普通函数,两个的内存区域是不一样的
        //并且static函数里面是没有this的;
    }  
  
    public void walk()  
    {  
        System.out.println(this.name+"会走路");  
        //这里可以调用eat()函数,是因为如果在main中对象调用了walk(),就会传入了一个this,this代表对象本身,对象是所有东西都可以拿到的,因此walk中可以调用eat函数
        eat();//this可以缩写,这是系统自带的,所以它的全称是this.eat();
    }  
  
}

public class text3 {  
    public static void main(String[] args) {  
  
        Person zs = new Person();  
        zs.name = "张三";  
        zs.age = 19;  
  
        Person ls = new Person();  
        ls.name = "李四";  
        ls.age = 19;  
        System.out.println(zs.name);  
        System.out.println(ls.name);  
  
        zs.walk();  
        ls.walk();  
    }  
}

对于类的对象来说,属性是每一个对象都有一份的,是数据隔离的,但是方法是多个数据共享的.不同的对象调用这个方法的时候,是用this来区分不同对象的数据,this是可以隐藏

3. 构造器

(每一个类被创建的时候都有一个构造器被创建出来,这个被叫做默认构造器,这是被隐藏的,看不到的)

用于创建对象的方法,固定格式,给对象赋初值;
我们使用new的时候相当于调用了类里面的构造器方法;

语法:

1. 没有返回值,没有void
2. 构造器的方法名必须与类名一致
3. 在方法中要定义要初始化的参数列表(非必须)

//默认构造器
权限修饰符 类名(){

}

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

}

注意点:

1. 如果一个类存在有参构造器,那么默认的构造器就会被覆盖,如果需要默认的构造器,就要显示其定义
2. 同一个类中的构造器可以互相调用,需用通过this()来调用,this()必须在第一行.
   需要在执行构造器功能之前,先初始化数据.

this();//这是调用了无参构造器
this(int .....);//这是调用了有参构造器

3. 在构造器中调用其他构造器,不会创建对象,只初始化;

有快速建立有参构造器的方法:

1. 在代码的空白处右击选择Generate,后再选择Constructor
2. 点击select None会自动帮我创建一个无参构造器
3. 也可以CTRL+A全选,然后点击OK创建出一个含有全部属性的构造器

4. static关键字

可以一句话来概括:方便再没有创建对象的情况下进行调用
被static关键字修饰的不需要创建对象去调用,直接根据类名就可以去访问
static一般用来修饰成员变量或函数;

public class test3 {  
  
  
    //当一个函数被创建的时候,被static修饰的函数叫做静态函数  
    //静态函数还有一个名字,叫做类函数,即这个函数属于类
    //对象就相当于类的儿子,可以使用这个函数,但是却未拥有这个函数
    public static void main(String[] args) {  
        Animal monkey = new Animal("猴子",100,"峨眉");  
        monkey.eat();  
        monkey.address();  
  
        Animal.address();  
    }


public class Animal {  
  
  
    //全局变量/成员变量/对象变量  
    public String name;  
    public int age;  
    public String address;  
  
  
  
    //普通函数(对象函数/成员函数)  
    public void eat()  
    {  
        System.out.println(this.name+"需要吃饭");  
    }  
  
    //类函数  
    public static void address()  
    {  
        System.out.println("每一个动物都有自己的家乡");  
    }  
    public Animal(){  
  
    }  
  
    public Animal(String name, int age, String address) {  
        this.name = name;  
        this.age = age;  
        this.address = address;  
    }

4.1.修饰成员变量

被static修饰的成员变量叫做静态变量,也叫做类变量,说明这个成员变量是属于这个类的,而不是属于对象(但是对象可以使用),没有被static修饰的成员变量叫做实例变量,说明这个变量是属于某个具体的对象的

public static void main(String[] args) {  
    Animal monkey = new Animal("猴子",100,"峨眉");  
    monkey.sex = "男";  

    Animal panda = new Animal("熊猫",100,"中国");  
    panda.sex = "女";  
  
    System.out.println(monkey.sex);//父亲的sex  
    System.out.println(panda.sex);//也是父亲的sex  
}

最后输出的两个性别都是女,因为sex在类中被static修饰,是属于类的变量

4.2修饰方法

static修饰方法的时候,可以直接通过类名来进行调用

public static void main(String[] args) {  
    Animal monkey = new Animal("猴子",100,"峨眉");  
    monkey.address();  //monkey为对象
  
    Animal.address();//Animal为类名
}

static最大的作用就是帮助我们做封装,程序员走到后期,都是要走架构这个方向

4.3 注意事项

1. 静态的方法只能访问静态的成员(静态成员即静态成员变量和静态方法),而普通函数就可以调用静态的变量和方法,是因为普通函数被传入了this这个参数,就可以通过对象进行调用了
2. 静态函数里面不可使用this或者supper
   因为this是属于对象的,而static是属于类的,类中没有对象

4.4 静态代码块(做项目的时候会用到,考试的时候也是重要的考点)

1. 静态代码块只在类加载的时候执行一次,经常用于初始化资源(关键数据).优于构造器.
2. 静态代码块在main之前执行

语法:
class A{
//静态代码块
static{
}
}

内存结构(这要映入脑海中)

方法区:Java中.java文件会被编译成.class文件,这就存放在类中
栈:对象名存入与此,而在堆中会有一片区域来存放该对象的内容(成员变量,成员函数)
静态区域:也是属于类的一块区域
![[Pasted image 20231228141709.png]]

技巧:

1. 在src处点击创建class,然后输入com.mashang.Person:则会将前两部分作为package名,最后一部分作为class名;
2. 创建构造器:空白处右击,选择:Generate,然后选择Constructer

5、final关键字

final是【最终】的意思。final是一个关键字，它可以被用来修饰类，变量以及成员方法。

5.1 修饰变量

变量分为成员变量和局部变量，他们被final修饰时有不同的注意事项。

1. 修饰成员变量

被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;

    }

}

2. 修饰局部变量

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

final int a =s

5.2 修饰成员方法

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

// 学生类

public class Student {

    public String name;

    public final void study() {

        System.out.println("好好学习！！");

    }

}


// 小学生类

public class Pupil extends Student{

    // 编译报错，study是final修饰的，不能被重写

    public void study() {

    }
}

5.3 修饰类

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

// final修饰学生类

public final class Student {

}

// 不能继承final类，编译报错

public class Pupil extends Student{

}

6. 封装-权限修饰符

	同一个类	同一个包	不同包非子类	不同包子类
private	可以访问	不可以访问	不可以访问	不可以访问
public	可以访问	可以访问	可以访问	可以访问
protected	可以访问	可以访问	不可以访问	可以访问
default	可以访问	可以访问	不可以访问	不可以访问

1. public：共有访问。对所有的类都可见。

2. protected：保护型访问。对同一个包可见，对不同的包的子类可见。

3. default：默认访问权限。只对同一个包可见，注意对不同的包的子类不可见。

4. private：私有访问。只对同一个类可见，其余都不见。【极大提高程序的安全性】

private只能在当前类进行使用,出了这个类就不能使用了;
public:不管你在哪个地方,都可以随便用;
protected,default:使用的非常少;
如果定义时没有使用权限修饰符,那么会默认为default类型

如果用private修饰属性的话,创建对象的时候就不可以初始化了,故需要函数来实现初始化;
即创建公共的set与get函数,在函数中通过this来进行赋值;
这就使得私有变量足够安全,并且可以进行赋值

所以以后设置属性与方法的时候尽量使用private,然后再设置set与get函数完成取值与赋值,代码的标准都是这样的;
系统给我们设置了快捷键,让我们在设置完这个private之后呢可以快速生成set与get函数:

1. 空白处右击选择Genrate,然后选择Getter and Setter
2. 然后CTRL+A全选,点击ok;

工作中都是以使用private为主,主要是为了安全;

7.单例(Singleton)

最终作用:返回有且只有一个对象(数据源唯一);

单例模式是一种常用的软件设计模式,通过单例模式可以保证系统中一个类只有一个对象;

应用场景:windows资源管理系统,Java数据库中的连接池,网站的计数器(网页的跳转然后点击返回).一般使用单例模式实现,否则难以同步.

步骤:

1. 私有化构造器(防止别人也可以创建对象),定义一个私有的成员变量(用于保存当前对象)
2. 定义一个类方法用于获取单例对象
3. 在类中提供一个这个类类型的类属性(用static修饰)
4. 在类方法种返回实例化对象

/**

 * 懒汉式单例

 */

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;

    }

}