Java类和对象&&封装&&构造方法分析

⭐前言⭐

本文将介绍Java中的类和对象。

🎉欢迎关注🔎点赞👍收藏⭐️留言📝
🔑GithubJava仓库，欢迎点击访问🔑
📝博主的笔记链接，第一时间更新📝

🌲类

类是构造对象的模板或蓝图。由类构造对象的过程称为创建类的实例。

类的成员可以包含以下：

1. 字段

   属性或者成员，又分普通成员变量和静态成员变量

   普通成员变量：属于对象，放在堆区，通过对象访问

   静态成员变量：属于类，放在方法区，又称类变量，通过类名访问

2. 方法

3. 代码块

4. 内部类

5. 接口

普通成员

class Person{
    public String name;
    public int age;
    public void eat(){
        System.out.println(name+" is eat");
    }//方法
}
public class Main {
    public static void main(String[] args) {
        Person play1=new Person();//类实例化为对象
        System.out.println(play1.name);
        System.out.println(play1.age);
        play1.eat();
    }
}

我们在使用时没有初始化，引用类型默认字符串为null，整型为0，布尔型为false

我们对其初始化后，再进行访问

public class Main {
    public static void main(String[] args) {
        Person play1=new Person();
        play1.name="number1";
        play1.age=18;
        Person play2=new Person();
        play2.name="number2";
        play2.age=19;
        System.out.println("名字:"+play1.name+" 年龄:"+play1.age);
        System.out.println("名字:"+play2.name+" 年龄:"+play2.age);
    }
}

名字:number1 年龄:18
名字:number2 年龄:19

由此我们看出，普通成员变量是属于对象，我们对实例化第二个对象并且初始化赋值的时候并不会影响第一个对象的值。

静态成员变量

普通成员变量属于对象，而静态成员属于类

class Person{
    public String name;
    public int age;
    public static int count;
}
public class Main {
    public static void main(String[] args) {
        Person play1=new Person();
        Person play2=new Person();
        play1.count=1;
        play2.count=2;
        System.out.println(play1.count);
        System.out.println(play2.count);
    }
}

我们看见

1. 通过对象访问静态变量有警告
2. “初始化”不同但是输出结果相同并且以结果第二个

事实上，静态成员变量属于类，我们可以通过类直接访问静态变量而不需要实例化一个对象

我们知道引用放在栈区上，对象放在堆区，那么静态变量放在那里？放在方法区

与此对应的还有静态方法，我们通过类就能直接访问方法。

static定义的变量属于类，叫做类变量；定义的方法叫做类方法。

需要注意的是

1. 普通成员方法内不能定义静态变量。（可以看见直接报错，语法不支持。）

2. 静态方法内部不可以调用普通方法（调用普通方法需要对象）

3. 普通方法内部可以调用静态方法

4. 静态方法内部可以访问静态变量但是不能定义静态变量

🌲封装

private实现封装

private和public这两个关键字表示"访问权限控制"。

1. 被public修饰的成员变量或者成员方法，可以被类直接调用者调用。
2. 被private修饰的成员变量或者成员方法，不能被类的调用者调用。

换句话说, 类的使用者根本不需要知道, 也不需要关注一个类都有哪些 private 的成员. 从而让类调用者以更低的成本来使用类。

getter和setter方法

class Person{
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}
public class Main {
    public static void main(String[] args) {
        Person person =new Person();
        person.setAge(18);
        person.setName("number");
        System.out.println(person.getAge());
        System.out.println(person.getName());
    }
}

需要注意的是

set和get方法再idea编译器中提供，可以直接生成。

注意以下错误

public void setAge(int age) {
        age = age;//不会赋值，两个age是相同age（局部变量有限）
}

🌲构造方法

定义：方法名和类名是相同的，并且构造方法没有返回值。

步骤：为对象分配内存---->调用合适的分配方法

合适的意味着调用方法不止一个。

需要注意的有

1. 方法名称必须与类名称相同
2. 构造方法没有返回值类型声明
3. 每一个类中一定至少存在一个构造方法（没有明确定义，则系统自动生成一个无参构造）
4. 如果类中没有提供任何的构造函数，那么编译器会默认生成一个不带有参数的构造函数
5. 若类中定义了构造方法，则默认的无参构造将不再生成.
6. 构造方法支持重载. 规则和普通方法的重载一致.

class Person{
    public String name;
    public int age;

    public Person(String name,int age){
        this.age=age;
        this.name=name;
    }
    public Person(String name){
        this.name=name;
    }
    public Person(){
        System.out.println("无参数");
    }
}
public class Main {
    public static void main(String[] args) {
        Person person1 =new Person();
        Person person2 =new Person("zhangsan");
        Person person3 =new Person("lisi",18);
        System.out.println(person1.name+"   "+person1.age);
        System.out.println(person2.name+"   "+person2.age);
        System.out.println(person3.name+"   "+person3.age);

    }
}

无参数
null 0
zhangsan 0
lisi 18

🌲关键字this

this和super有什么区别？

this.data--------调用当前对象的属性

this.func()------调用当前对象的方法

this()-------------调用当前对象的其他构造方法，只能存放在构造函数中

必须放到第一行

🌲代码块

本地代码块

实例代码块

静态代码块

同步代码块

class Person{
    public String name;
    public int age;
    {
        System.out.println("实例代码块");
    }
    static {
        System.out.println("静态代码块");
    }
    static int a=0;
}
public class Main {
    public static void main(String[] args) {
        Person person=new Person();
        System.out.println(person);
    }
}

静态代码块
实例代码块
Person@1b6d3586

我们可以看见静态代码块是最先被执行的并且静态代码块只会被执行一次

并且静态代码块不用实例化对象也会被执行

代码块怎么被调用？

静态代码块执行在实例代码块前，并且静态代码块只执行一次

就算不用实例化为对象也会执行一次

💎结尾语💎

博客根据笔记改动而来，如有错误欢迎评论指正，感激不敬。