Java类和对象知识点（小结）

近期刚刚开始接触Java，特此根据现有知识对Java基本和运算符做以小结，以下博客仅作为个人学习过程的小结，如能对各位博友有所帮助不胜荣幸。
本篇博客将简单介绍Java对象的认识，以及类的基本使用规则，只做本人小结，后期随学习深入再做补充修改。

Java类和对象：

1、对象的认知
Java与C面向过程的不同，Java是一门面向对象的语言，将一个事情的解决方案拆分成面向多个对象，靠对象间交互完成实现。
面向过程就是注重，实现整个时间所涉及的行为，就是功能。
面向对象就是注重，参与过程的主体，就是通过逻辑将多个功能实现连接。
对象的概念：
1.面向对象是一个思考问题的一种思考方式
2.面向对象的好处，将复杂的事情变简单，只需要考虑对象
3.例如将大象装冰箱，面向过程需要每步自己实现：打开冰箱门，放大象，关门。面向对象则是以上对冰箱的操作，都是冰箱的行为。而冰箱就是一个对象，无需管冰箱是如何操作实现的，只要去操作冰箱所具备的功能。
4.而类就是一类对象的统称，对象就是类的实例化
简而言之：
面向对象就是用代码（类）来描述客观世界的事物的一种方式，一个类主要包含一个事物的属性和行为。
2、类的认知
类就是一群对象的统称，对象就是这一类具体化的实例。
例如：对于做月饼的模具来说，模具就是类，月饼就是由模具具体化的实例
再例如：对于建房子的图纸来说，图纸就是类，房子就是由图纸具体化的实例
一个类可以产生多个对象，在Java中类属于引用类型，用class声明

//声明一个类
class People {
    //属性
    public String name;
    public int height;
    public int weight;
    //行为
    public void sleep(){
        System.out.println("睡觉");
    }
    public void walk(){
        System.out.println("走路");
    }
}

3.类的实例化
用类来创建对象，叫做类的实例化
1.类只是一个模型，限定了所创建对象所拥有的属性和行为。
2.一个类可以实例化多个对象，实例化出的对象占用实际空间，储存类空间变量。
注意事项：

• new关键字用于创建一个对象的实例
• 使用 . 来访问对象中的属性和行为
• 同一个类可以创建多个对象

4.类的成员
类的成员包含：字段、方法、代码块、内部类和接口等。
4.1：字段/（属性）/（成员变量）
在类中，方法外定义的变量，这种变量称为字段（又叫属性，还叫成员变量）。
注意事项

• 使用 . 访问对象的字段
• “访问”包含读和写
• 当一个对象的字段没有设置初始值时，将被设置一个默认值（1、对于各种类型的数字，默认值为0， 2、对于Boolean类型，默认值为false， 3、对于引用类型，默认值为null）

null 在 Java 中为“空引用”，表现不引用任何对象，类似于C中的空指针，所以当对 null 进行.操作时，就会报错。
4.2：方法
用于描述一个对象的行为

class People {
    public int height;
    public int weight;
    public void show(){
        //方法：
        System.out.println(this.height+" "+this.weight);
    }
}

上述代码的的show（）方法，表示Peopel这个对象具的一个行为。
4.3：static 关键字
1、修饰属性，Java具体事例与类相关，和具体事例无关，同一个的不同事例共用同一个静态属性。

class sampleDemo {
    public int a;//成员变量
    public static int count;//被static修饰的静态属性
}

public class TestDemo {


    public static void main(String[] args) {
        sampleDemo sd = new sampleDemo();//创建一个新对象
        sd.a++;
        sampleDemo.count++;
        System.out.println(sd.a+" "+sampleDemo.count);
        System.out.println("===========================");
        sampleDemo sa = new sampleDemo();//创建又一个新对象
        sa.a++;
        sampleDemo.count++;
        System.out.println(sa.a+" "+sampleDemo.count);
    }
}

上述代码 count 被 static 修饰，类共享，且不属于对象，访问方法：类名.属性。
在Java中，类创建的对象储存在堆上，其引用存放在虚拟机栈上，而其中被 static 修饰的变量存放在方法区中，类共享。

2、修饰方法，在任何方法上用 static 修饰，此方法就变为静态方法

• 静态方法属于类，但不属于类的对象
• 静态方法可直接调用，无需创建类的实例
• 静态方法可以访问静态数据成员，并可以更改静态数据成员的值

class SampleDemo {
    public int a;
    public static int count;//被static修饰的静态属性
    public static void change(){
        count = 10;//运用static修饰的静态方法，可以调用及修改静态数据成员
        a = 100;//但static修饰的静态方法不能调用非静态数据成员
    }
}

注意事项：被static修饰的方法（静态方法）与实例无关，而和类相关。导致

• 静态方法不能直接使用非静态成员或调用非静态方法（这两个都和实例相关）
• this和super两个关键字不能在静态上下文中使用（this是当前实例的引用，super是当前实例父亲实例的引用）

class SampleDemo {
    public String str;//实例变量
    public int a;//实例变量
    public final int b = 10;//被final修饰不可修改的实例变量
    public static int c;//静态变量
    public static final int d = 20;//被final修饰不可修改的静态变量
    //实例成员方法
    public void change(){
        a = 20;
    }
    //静态成员方法
    public static void tansfer(){
        c = 100;
    }
}

public class TestDemo {

    public static void main(String[] args) {
        //实例化一个对象
        SampleDemo sd = new SampleDemo();//sd为对象的引用
        System.out.println("str="+sd.str);//未初始化的，String类型的实例变量默认值为null
        System.out.println("a="+sd.a);//未初始化的，ing类型的实例变量默认值为0
        System.out.println("b="+sd.b);
        //被static修饰的方法和属性，全部不依赖于对象
        System.out.println("调用tansfer方法前：c="+SampleDemo.c);
        SampleDemo.tansfer();
        System.out.println("调用tansfer方法后：c="+SampleDemo.c);
        System.out.println("d="+SampleDemo.d);
    }
}

5.封装
我们写代码时通常会有，类的实现者和类的调用者
封装的本质就是让类的调用者不必太多的了解类的实现着如何实现类的，只要知道如何使用类，这样就大大降低了调用者的学习成本。
5.1 private封装
private和public 这两个关键字表示“访问权限的控制”

• 被 public 修饰的成员变量可以被调用者直接使用
• 被 private 修饰的成员变量不能被调用者使用
• private 还可以修饰成员方法，但一般情况成员方法都是 public 修饰，具体用什么修饰视具体情况而定

5.2 getter和srtter方法
当使用 private 修饰成员变量后，就无法直接使用该字段了，即无法获取和修改 private 属性
如果此时需要获取和修改该属性，则需要使用 getter / setter方法

class SampleDemo {
    private int a;//成员变量

    public int getA() {//获取这个成员变量
        return a;
    }

    public void setA(int a) {//设置这个成员变量
        this.a = a;//this表示当前实例的引用
    }
}

public class TestDemo {
    public static void main(String[] args) {
        SampleDemo sd = new SampleDemo();//实例化一个对象
        sd.setA(20);//给对象里的成员变量赋值
        System.out.println(sd.getA());
    }
}

注意事项：

• 当set方法的形参名字和类中的成员属性名字一样时，需要使用this，如果不用this相当于自赋值.this表示当前实例的引用
• 不一定所有字段都需要 setter和getter ，根据具体情况而定
• 在 IDEA 中可使用快捷键alt+inset，快速生成 setter和getter方法

6.构造方法
6.1 基本方法
构造方法是一种特殊的方法，使用 new 关键字实例化新对象时会被自动调用，并完成初始化
new 的执行过程：

• 给对象分配内存
• 调用对象的构造方法

构造方法的语法规则：

• 方法名必须与类名相同
• 构造方法没有返回值类型声明
• 每一个类至少有一个构造方法（如果没有定义，系统会自动生成一个空方法）

注意事项：

• 如果类中没有定义任何构造方法，那么系统会任意生成一个不带任何参数的空构造方法
• 如果类中定义了构造方法，则原默认的无参构造方法将不再生成
• 构造方法支持重载，规则如下：
  1、方法名相同
  2、方法的参数不同
  3、返回值类型不作要求

6.2 this关键字
this 表示当前对象的引用，可以借助 this 来访问对象的字段和方法

class People{
    private String name;
    private int age;
    private String sex;

    public People(){
        this("张三",18,"男");
        //People类的构造方法中调用其他构造方法，this(参数列表)
    }
    public People(String name,int age,String sex){
        System.out.println(name+" "+age+" "+sex);
        //构造方法
    }

    public void show(){
        System.out.println(this.name+" "+this.age+" "+this.sex);
    }

}

public class TestDemo {
    public static void main(String[] args) {
        People p = new People();
        p.show();
    }
}

7.代码块
7.1 什么是代码块
在{ }里定义的一段代码称为代码块
根据代码块的位置和其关键字可以分为：

• 普通代码块
• 构造块
• 静态块
• 同步代码块

7.2 普通代码块
定义在方法中的代码块

class ExampleDemo{

    private int a;
    public void fun(int num){
        {
            this.a = num; 
        }
        //方法中定义的普通代码块
        System.out.println(this.a);
    }

}

6.3构造块
定义在类中的代码块。也叫实例代码块

class ExampleDemo{

    private int a;
    private int b;
    private String str;
    {
        this.a = 10;
        this.b = 45;
        this.str = "hello";
    }
    //实例代码块
    public void show(){
        System.out.println(this.a+" "+this.b+" "+this.str);
    }
}

无论位置如何，实例代码块优先于构造方法执行
6.4 静态代码块
使用 static 修饰的代码块

class ExampleDemo{

    private int a;
    private int b;
    private String str;
    private static int count;
    public ExampleDemo(){
        {
            System.out.println("普通代码块");
        }
        //普通代码块
    }
    {
        this.a = 10;
        this.b = 45;
        this.str = "hello";
        System.out.println("实例代码块");
    }
    //实例代码块
    static{
        count = 100;
        System.out.println("静态代码块优先");
    }
    //静态代码块
    public void show(){
        System.out.println(this.a+" "+this.b+" "+this.str+" "+count);
    }
}

注意事项：

• 静态代码块不关类生成多少对象，其只执行一次，且最先执行
• 静态代码块全部执行完毕后，实例代码块再执行，最后普通代码块再执行

总结

• 一个类可以产生多个对象，类是模板，对象是具体实例
• 类中定义的属性大体可分为两种：类属性和对象属性。其中被 static 修饰的数据属性为类属性，static 修饰的方法为类方法，不依赖于对象，调用时无需创建对象只需用类名访问即可
• 静态代码块优于实例代码块优于普通代码块，实例代码块优于构造方法
• this 关键字代表当前对象（实例）的引用

以上便是Java类和对象的知识点小结，随着后续学习的深入还会同步的对内容进行补充和修改，如能帮助到各位博友将不胜荣幸，敬请斧正