浅谈Java类和对象

C语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。
JAVA是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。
面向过程注重的是过程，在整个过程中所涉及的行为，就是功能。
面向对象注重的是对象，也就是参与过程所涉及到的主体。是通过逻辑将一个个功能实现连接起来

类就是一类对象的统称。对象就是这一类具体化的一个实例。

类实例化

基本语法

// 创建类
class <class_name>{  
    field;//成员属性
    method;//成员方法
}

// 实例化对象
<class_name> <对象名> = new <class_name>();

class为定义类的关键字，ClassName为类的名字，{}中为类的主体。
类中的元素称为：成员属性。
类中的函数称为：成员方法。

示例：

class Person1{  //定义的类
    public String name; //成员属性  实例变量
    public int age;

    public void eat(){  //实现的方法
        System.out.println(name+"正在吃饭！");
    }

    public void sleep(){
        System.out.println(name+"正在睡觉！");
    }
    public void print(){
        System.out.println("我叫"+name+" 今年"+age+"岁了！");
    }
}

提问： 为什么这里方法会没有用static来修饰？
解释： 被static修饰的方法属于类方法，可以通过类名.方法名直接引用，而不需要new出一个类来。

class Person{
    public String name;
    public int age;
    public static int count; //静态成员变量 -> 类变量

    public void eat(){
        System.out.println(name+"正在吃饭！");
    }

    public void sleep(){
        System.out.println(name+"正在睡觉！");
    }
    public void print(){
        System.out.println("我叫"+name+" 今年"+age+"岁了！");
    }
}
public class TestDemo {

    public static void main(String[] args) {
        Person person = new Person();
        person.age++;
        person.count++;
        System.out.println(person.age);
        System.out.println(person.count);
        System.out.println("===========");
        Person person1 = new Person();
        person1.age++;
        person1.count++;
        System.out.println(person1.age);
        System.out.println(person1.count);
    }

static属于类名的，不依赖于对象，直接Person.count使用。
注意：
1.普通方法里不能定义静态变量
2.静态方法里也不能定义静态变量
3.普通方法内部可以调用静态方法
4.静态方法内部不能调用普通方法 （一定要用，就要new一个对象来调用了。）

难点问题：main函数为什么是静态的？？？
解答：首先，main函数是不是静态的都可以，这个东西取决于JVM。他自己设置成这样的就行。

注意，一个引用不能同时指向多个对象
引用不一定都在栈上

class Person{
    public String name;
    public int age;

    public void eat(){
        System.out.println(name+"正在吃饭！");
    }

    public void sleep(){
        System.out.println(name+"正在睡觉！");
    }
    public void print(){
        System.out.println("我叫"+name+" 今年"+age+"岁了！");
    }
}
public class TestDemo {

    public static void main(String[] args) {
            Person person = new Person();//通过new实例化对象
              person.name = "dabi";  //赋值
              person.age = 20;
                person.eat();//成员方法调用需要通过对象的引用调用
                person.sleep();
                person.print();
                //产生对象 实例化对象
             Person person2 = new Person();
                 Person person3 = new Person();
    }

注意事项
new 关键字用于创建一个对象的实例.
使用 . 来访问对象中的属性和方法.
同一个类可以创建对个实例.

默认值规则
对于各种数字类型, 默认值为 0.
对于 boolean 类型, 默认值为 false.
对于引用类型(String, Array, 以及自定制类), 默认值为 null

一个对象 存储到哪里，和你是否被final修饰没关系

封装

private String name;   //只能在当前类当中使用

要使用，用get获取，set改变
好处：属性更安全了 ，他不会暴露在类外了
快捷键：Alt + Insert

//    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 static void main5(String[] args) {
//        Person person = new Person();
//        //person.name = "bit";
//        person.setName("bit");
//       // person.age = 19;
//        person.setAge(19);
//        System.out.println(person.getName());
//        System.out.println(person.getAge());
//    }

构造方法

方法名和类名是相同的。且构造方法比较特殊，没有返回值。
构造方法是干嘛的？ -> 一个对象的产生【对象的实例化】
1.为对象分配内存。
2.调用合适的构造方法。（构造方法不止一个）

//    public Person(){
//        this("chenman");//调用带有1个参数的构造方法
//        System.out.println("Person()::不带参数的构造方法");
//    }
//
//    public Person(String name){
//        this.name = name;
//        System.out.println("Person(String)::带一个String类型参数的构造方法");
//    }
//
//    public Person(String name,int age){
//        this.name = name;
//        this.age = age;
//        System.out.println("Person(String,age)::带两个‘一个String，一个age’类型参数的构造方法");
//    }

注意1：
1.如果没有实现任何的构造方法，编译器会帮我们，默认生成一个不带参数的构造方法。也就是说，一个类，至少会有一个构造方法，不管你有没有写！！！
2.如果当前类有其他的构造方法，那么，编译器就不会帮我们生成不带参数的构造方法的。
3.构造方法 之间 可以构成重载

注意2:
this代表当前的对象 这个是错误的？
他代表的是当前对象的引用。

this

1.this.data 调用当前对象的属性
2.this.func(） 调用当前对象的方法
3.this（） 调用当前对象的其他的构造方法，必须放在第一行，只能存放在构造函数当中（先打印他）

代码块

本地代码块
实例代码块
静态代码块
同步代码块

{
//        System.out.println("实例代码块");
//    }
//
//    static{
//        count = 99;
//        System.out.println("静态代码块");
//    }

1.静态代码块最先执行，不管在前还是在后。
2.只会被执行一次。不用实例化对象也能被执行。
3.类加载的时候执行。
4.如果都是静态的，和定义的顺序有关系。

总结

这一章节确实有点绕，博主现在对他也不是特别的懂，写的知识点也都是零零散散的，希望大家多多指正。在这里感谢大家观看，让我们一起加油克服它，你的支持就是我最大的动力！！！