类和对象（Java）

1.类和对象的初步认识

2.类和类的实例化

3.类的成员

3.1字段/属性/成员变量

3.2方法（method）

3.3static关键字

3.4小结

4.封装

4.1private实现封装

4.2getter和setter方法

5.构造方法

5.1基本语法

5.2this关键字

6.认识代码块

6.1什么是代码块

6.2普通代码块、构造块、静态块

7.内容重点总结

=================================

1.类和对象的初步认识

C语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。
JAVA是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。
面向过程注重的是过程，在整个过程中所涉及的行为，就是功能。
面向对象注重的是对象，也就是参与过程所涉及到的主体。是通过逻辑将一个个功能实现连接起来
面向过程： 1.把冰箱打开 2. 把大象放入 3. 冰箱关起来 面向对象： 打开冰箱，储存，关闭都是对冰箱的操作，是冰箱的行为。冰箱就是一个对象，所以只要操作冰箱所具备的功能，都要定义在冰箱中。

【面向对象概念】
1.面向对象是思考问题的一种思考方式，是一种思想。比如：概念与实例。理论与实践。
2.类就是一类对象的统称。对象就是这一类具体化的一个实例。
3.面向对象的好处：将复杂的事情变简单了，只要面对一个对象就行。

2.类和类的实例化

基本语法：

// 创建类
class <class_name>{
   field;//成员属性
   method;//成员方法
 }
// 实例化对象
<class_name> <对象名> = new <class_name>();

Java是基于面向对象的语言，关注的是对象，也就是参与过程所涉及到的主体。声明一个类就是创建一个新的数据类型，而类在Java中属于引用类型，Java中用关键字class来声明类。

一个简单的类声明~

 class Person {
        public int agr;
        public String sex;
        public void eat() {
            System.out.println("吃饭！");
        }
        public void sleep() {
            System.out.println("睡觉！");
        }
    }

class + 类名 （类名采用大驼峰的形式）

 public int agr;
 public String sex;

表示成员属性（field）

       public void eat() {
            System.out.println("吃饭！");
        }
        public void sleep() {
            System.out.println("睡觉！");
        }

表示成员方法（method），这里的方法不带static关键字。

类的实例化
实例化出的对象，占用实际的物理空间，储存类成员变量。

给出下面的例子：

   class Person {
        public int agr;//成员属性，实例变量
        public String sex;
        public void eat() {//成员方法
            System.out.println("吃饭！");
        }
        public void sleep() {
            System.out.println("睡觉！");
        }
    }
    public class Test {
        public static void main(String[] args) {
            Person person = new Person();//通过new实例化对象
            person.eat();//成员方法的调用需要通过对象的引用调用
            person.sleep();
            //实例化对象
            Person person2 = new Person();
            Person person3 = new Person();
        }
    }

1. 实例化一个对象：new Person()。
2. 由上面代码可以看出，一个类可以实例化多个对象。
3. 成员属性（成员变量、字段）：是在类里面、方法外面定义的变量。
4. 使用 . 来访问对象中的属性和方法。

3.类的成员

3.1字段/属性/成员变量

字段/属性/成员变量

字段/属性/成员变量用于描述一个类中包含哪些数据
具体示例如下：

class Person{
    public String name;
    public int age;
}
class Test {
     public static void main(String[] args) {
         Person person = new Person();
         System.out.println(person.name);
         System.out.println(person.age);
     }
 }

使用 . 访问对象的字段，“访问”既包含读，也包含写，对于一个对象的字段如果没有显示设置初始值，那么会被设置一个默认的初值。

默认值规则：
1、对于各种数字类型，默认值为0；
2、对于boolean类型，默认值为false；
3、对于引用类型（String,Array,以及自定制类），默认为null.

所以上述代码运行结果如下：

null
0

null在Java中为“空引用”，表示不引用任何对象，如果对null进行 . 操作就会引发异常。
字段可以就地初始化，如下：

class Person {
    public String name = "yuan";
    public int age = 18;
}
class Test {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person.name);
        System.out.println(person.age);
    }
}

3.2方法（method）

方法：描述一个对象的行为

代码示例如下：

class Person {
    public String name = "yuan";
    public int age = 18;
    public void show() {
        System.out.println("我叫 " + name + "," + "今年" + age);
    }
}
class Test {
    public static void main(String[] args) {
        Person person = new Person();
        person.show();
    }
}

用 对象引用 . 成员方法访问，这样的show方法是和person实例相关联的。

3.3static关键字

static 关键字：可以修饰属性、修饰方法

class Demo {
    public int a;
    public static int b;
}

class Test {
    public static void main(String[] args) {
        Demo demo1 = new Demo();
        Demo demo2 = new Demo();
        demo1.a ++;
        Demo.b ++;
        System.out.println(demo1.a);
        System.out.println(Demo.b);
        demo2.a++;
        Demo.b++;
        System.out.println(demo1.a);
        System.out.println(Demo.b);
    }
}

输出结果为 1 1 1 2，由此可以看出，Java静态属性和类相关，和具体的实例无关，换句话说，同一个类的不同实现公用同一个静态属性。b被static所修饰，所有类共享，且不属于对象（存在于方法区），访问方式为：类名.属性，所以在两次自加以后，b的值变为2，没有被static修饰的值变为1.

static修饰方法时，此方法称为静态方法。可以直接调用静态方法，无需创造类的实例；静态方法可以访问静态数据成员，并可以更改他的值。

class Demo {
    public int a;
    public static int b;
    public static void change() {
       // a = 10;错误，不能访问非静态数据成员
        b = 10;//可以更改静态数据成员的值
    }
}
public class Test{
    public static void main(String[] args) {
        Demo.change();//无需创建实例对象就可以调用
        Demo demo = new Demo();
        System.out.println(demo.a);
        System.out.println(Demo.b);
    }
}

静态方法不能直接使用非静态成员数据或调用非静态方法。
一个方法具体要不要带static，要视情况而定，但是main方法为static方法。

4.封装

4.1private实现封装

private实现封装，不但能修饰字段，还能修饰方法。

class Person {
    private String name = "zhangsan";
    private int age = 18;
    public void show() {
        System.out.println(name + age);
    }
}
public class Test {
    public static void main(String[] args) {
        Person person = new Person();
        person.show();
    }
}

字段使用private来修饰，类的调用者（main）不能直接使用，需要借助show（）方法，带来了诸多方便。

4.2getter和setter方法

getter和setter方法，idea中使用alt+insert来自动生成。使用private修饰字段时，无法直接使用这个字段，所以需要这两个方法来使用字段。

class Person {
    private String name;
    private int age;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;//this引用，表示调用该方法的对象
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public void show() {
        System.out.println(name + age);
    }
}

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

5.构造方法

5.1基本语法

构造方法是一种特殊方法, 使用关键字new实例化新对象时会被自动调用, 用于完成初始化操作

基本语法：方法名与类名相同，构造方法没有返回值类型申明，每一个类中至少含有一个构造方法（没有定义，则系统自动生成），构造方法也支持重载，规则与普通方法重载一致。

class Person {
    private String name;
    private String sex;
    private int age;
    //默认构造方法
    public Person() {
        this.name = "zhangsan";
        this.sex = "nan";
        this.age = 18;
    }
    //带有3个参数的构造方法
    public Person (String name, String sex,int age) {
        this.name = name;
        this.sex = sex;
        this.age = age;
    }
    public void show() {
        System.out.println(name + sex + age);
    }
}
public class Test {
    public static void main(String[] args) {
        Person p1 = new Person();
        //调用不带参数的构造方法
        p1.show();
        Person p2 = new Person("zhang","nv",17);
        //调用带有三个参数的1构造方法
        p2.show();
    }
}

5.2this关键字

this表示当前对象引用（注意不是当前对象）

1. this.成员变量。只能是普通成员变量，不能是静态成员变量。
2. this.成员方法。规则与上方一样
   3.this（）.构造方法。调用一个参数的构造方法，且是String类型

6.认识代码块

6.1什么是代码块

使用 {} 定义的一段代码.
根据代码块定义的位置以及关键字，又可分为以下四种：
普通代码块
构造块
静态块
同步代码块

6.2普通代码块、构造块、静态块

普通代码块：定义在方法中的代码块
实例代码块（构造代码块）：定义在类中的代码块（一般用于初始化实例成员变量）
静态代码块：使用static定义的代码块（静态不依赖于对象）

class Person {
    private String name;
    private String sex;
    private int age;
    private static int count = 0;
    public Person() {
        System.out.println("初始化");
    }
    {
        this.name = "zhangsan";
        this.sex = "nan";
        this.age = 18;
        System.out.println("实例代码块");
    }
    static  {
        count = 10;
        System.out.println("静态代码块");
    }
    public void show() {
        System.out.println(name + sex + age);
    }
}

public class Test {
    public static void main(String[] args) {
        Person p1 = new Person();
        p1.show();
        Person p2 = new Person();
        p2.show();
    }
}

运行结果：

静态代码块
实例代码块
初始化
zhangsannan18
实例代码块
初始化
zhangsannan18

由此可以看出，静态代码块只执行一次，且是最先执行的，静态代码块执行完毕后，实例代码块执行，最后构造函数执行。

7.内容重点总结

1.一个类可以产生无数的对象，类就是模板，对象就是具体的实例。
2.类中定义的属性，大概分为几类：类属性，对象属性。其中被static所修饰的数据属性称为类属性, static修饰的方法称为类方法，特点是不依赖于对象，我们只需要通过类名就可以调用其属性或者方法。
3.静态代码块优先实例代码块执行，实例代码块优先构造函数执行。
4.this关键字代表的是当前对象的引用。并不是当前对象。