类和对象

什么是面向对象，什么是面向过程
- 面向对象概念
- 面向对象设计
正文开始类的创建以及实例化
怎么使用这个类
static 在类中的使用
this 的使用
构造方法
代码块
匿名对象
总结
关于小编

首先什么是类呢？类就是一堆具有相同属性的集合。类就是引用类型。比如，人都有年龄，性别，名字。我们就可以把这个人做成一个类。
那什么又是对象呢？对象不是你媳妇。比如人的年龄，性别，就是对象。他是指我们研究的对象。下面就要进入正题了。

什么是面向对象，什么是面向过程

 面向过程： 1.把冰箱打开 2. 把大象放入 3. 冰箱关起来 
 面向对象： 打开冰箱，储存，关闭都是对冰箱的操作，是冰箱的行为。
 冰箱就是一个对象，所以只要操作冰箱所具备的功能，都要定义在冰箱中。

不知以上解释可否满意呢？

面向对象概念

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

面向对象设计

面向对象设计把握一个重要的经验：谁拥有数据，谁对外提供操作这些数据（私有）的方法！（被动的一方是数据的拥有者，主动的一方是执行者）
开发时：找对象，建对象，用对象，并维护对象之间的关系。 以后学习过程当中，我们会就这三点进行深入学习。

  说了那么多该来点实际操作了

正文开始类的创建以及实例化

我先拿来一串代码。

class Person {
    
    
    public int age;//成员属性 实例变量
    public String name;
    public String sex;
    public void eat() {
    
    //成员方法
       System.out.println("吃饭!");  
   }
    public void sleep() {
    
    
       System.out.println("睡觉!");  
   }
}

我们要知道。以上代码就是类的创建，创建类的关键字就是class； Person 也就是我们C语言说的结构体（比结构体要牛）也就是自定义类型， public 叫做访问修饰符，也就是我们所说的权限，public 就是公有的，大家都能使用的。那么什么又是实例化类呢？

Person person = new Person();

那么这个就是实例化Person类，
这就是类的创建和实例化了。

怎么使用这个类

使用 . 来访问对象中的属性和方法.
下面看代码。

class Person {
    
    
    public int age;//成员属性 实例变量
    public String name;
    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();
        person.name = "WeiRan";
        person.sex = "男";
        person.age = 19; //因为类中 age为int型。所以person.age也是整型，因为我们是用过对象访问的年龄。
        System.out.println(person.name);
        System.out.println(person.sex);
        System.out.println(person.age);
    }
}

代码有点长，但我相信很好理解。毕竟我在中间也加了注释呢。在这里我们发现可以直接赋值，，简单嘛？简单的很啊，下面我说一下注意事项

new 关键字用于创建一个对象的实例.
使用 . 来访问对象中的属性和方法.
同一个类可以创建多个实例.
对于同一个类可以创建多个实例. 这句话的理解呢，我们看一个代码；便可以理解

        Person person  = new Person();
        Person person1  = new Person();
        Person person2  = new Person();
        Person person3  = new Person();
        Person person4 = new Person();

我们可以用这样的方式实现代码，每次new一个便可以在堆区创建一块空间，在这里我要给大家扩展一点

扩展

1 在代码：Person person = new Person(); 中，person在栈区存储它身上存着一块地址。比如我运行一下。
在这里插入图片描述
你们看，运行结果是类名+字符@+地址。当然我们如何解决这个问题呢。比如我们如果想要输出类内的元素
我说下步骤：

将鼠标光标移动到类内，按住alt+ins键ins也就是我们平常所说的插入键
他会弹出这样的小框框，我们选择toString()；
我们将其全部选中再点击ok即可，代码将会自动补入。
做好这一切，我们再运行一遍，看看结果是否满意：

在这里插入图片描述
这个结果便是我们想要的了。当然有点小知识：new再堆区开空间，有默认值的，大家可以看我之前写的博客在这里我就说一下，引用类型默认为null

介绍null

null 在 Java 中为 “空引用”, 表示不引用任何对象. 类似于 C 语言中的空指针. 如果对 null 进行 . 操作就会引发异常.

字段/属性/成员变量

其实我们再类内定义的变量就被成为字段，属性，成员变量我们不强制叫做什么，比如我就喊他元素。

字段就地初始化

什么是就地初始化呢，就是在类内对字段进行初始化。

class Person {
    
    
    public String name = "张三";
    public int age = 18; }

这就叫就地初始化当然我们这样初始化可以理解为在方法内使用时，我们如果是初始化这个类，那么name，age字段就有了初始值

方法

方法就是类内使用方法。大家可以看代码！其实这个知识点特别简单哦

class Person {
    
    
    public int age;//成员属性 实例变量
    public String name = "Weiran";
    public String sex;
    public void eat() {
    
    //成员方法
        System.out.println("吃饭!");
    }
    public void sleep() {
    
    
        System.out.println("睡觉!");
    }

    @Override
    public String toString() {
    
    
        return "Person{" +
                "age=" + age +
                ", name='" + name + '\'' +
                ", sex='" + sex + '\'' +
                '}';
    }
}

public class Test {
    
    
    public static void main(String[] args) {
    
    
        Person person  = new Person();
        person.eat();
    }
}

看这个代码，。其实就是调用类里面的函数，就完了，好了。以上就是类的基础了。下一个模块就要变的难咯。建议大家看到这里先去练练手，把类吃明白了，再继续看

static 在类中的使用

修饰属性

由上文我相信大家可以知道属性，字段，成员变量是一个东西。也就是我们类里面的变量。一个类如果是一个集合的话。那么属性/字段就是元素。下面看一遍代码吧，在下将用代码解释所有

class Person{
    
    
    public static int count;
    public int n;
}

定义方法很简单咯。就是将count定义成静态的整型变量，权限为公开。下面我让你看看他的不同之处在哪里吧

    public static void main(String[] args) {
    
    
        Person p1 = new Person();
        Person p2 = new Person();
        p1.count++;
        p1.n++;
        System.out.println(p1.count);
        System.out.println(p1.n);
        p2.count++;
        p2.n++;
        System.out.println(p2.n);
        System.out.println(p2.count);
    }

在这里插入图片描述

这串代码便是直接使用的上图中的类。大家运行可以发现。静态变量： p1.count++ 第一次执行的时候从0变成了1 第二次执行则是再 1 的基础上再加。而非静态变量呢。定义一次初始化一次。看到这里再联想之前的知识。我们就可以发现，在类中普通变量在使用时。则是在不同堆区进行改变。而 new p2 是 count 使用的还是原来那块空间。当然在这里我就不让大家思考了。我直接说原因了

首先，类开辟实在堆区，每次new一下就会在堆区再次开辟一个空间
静态变量存在静态区，count使用时应为类名.count
看完以上两点是不是就明白了很多了？既然时类名.count 我们会发现他们似乎就是一样哒。
当然我们之前使用p1,p1时我们会发现编译器会给我们警告的，而换成类名.count 则没有。

大家看以上两行代码使用p1.count 带阴影便是警告。而类名.count 则没有阴影

修饰方法

      如果在任何方法上应用 static 关键字，此方法称为静态方法

看到上面这句话我们应该就知道上面时静态方法了下面我给大家介绍几点重点吧

静态方法属于类，而不属于类的对象。
可以直接调用静态方法，而无需创建类的实例。
静态方法可以访问静态数据成员，并可以更改静态数据成员的值。
对于第一点我们应该怎么理解呢？
有静态变量，我们发现，静态变量要用类名实现，而不能使用类名new出来的对象实现，所以我们说静态方法属于类，而不属于类的对象。
那么第二句话呢？我们可以看一个代码

其实第二句话的意思就是。我们使用静态方法的时候直接使用类名.方法即可不需要再new出来一个老婆。再用老婆召唤这个方法了。
下面开始理解第三句话。

    public static void show(){
    
    
        System.out.println("Hello World!!!");
        count = 10;
    }

    public void exitInt(){
    
    
        count = 20;
    }

小编建议大家将这一步放到编译器上，交换顺序看打印结果。，我们会发现，count始终等于10；
当然在这里静态变量不能调用非静态变量的值，
在这里插入图片描述
还有一点大家一定要避坑。就是非静态方法不能改变静态变量的值，但是访问并不报错。所以以后如果在这里写错可是会很头疼的哦！！！

封装

下面我们开始介绍封装，什么叫封装呢？封装就是将数据保存起来，提高java数据的安全型，不让别人看见，

<<代码大全>> 开篇就在讨论一个问题: 软件开发的本质就是对程序复杂程度的管理. 如果一个软件代码复杂程
度太高, 那么就无法继续维护. 如何管理复杂程度? 封装就是最基本的方法.
在我们写代码的时候经常会涉及两种角色: 类的实现者和类的调用者.
封装的本质就是让类的调用者不必太多的了解类的实现者是如何实现类的, 只要知道如何使用类就行了.
这样就降低了类使用者的学习和使用成本, 从而降低了复杂程度

被 public 修饰的成员变量或者成员方法, 可以直接被类的调用者使用.
被 private 修饰的成员变量或者成员方法, 不能被类的调用者使用.
下面我们开始使用private以及public 当然public我们前面就一直使用就是公开的，大家都可以用啊
但是我们如果把这些每个数据都公开了，又谁想用谁用。岂不是一点安全性没有了。
其实在这里我们主要是会用这些就好啦，我直接用代码表示使用吧。

class Person {
    
     
 private String name = "张三"; 
 private 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(); 
 } 
}

这个代码可以看出。我们的private 修饰完名字和年龄后，再主方法里并不能访问名字和年龄了。只能通过类内的方法进行访问。这样就提高了java语言的安全程度。

注意事项

private 不光能修饰字段, 也能修饰方法
通常情况下我们会把字段设为 private 属性, 但是方法是否需要设为 public, 就需要视具体情形而定. 一般我们希望一个类只提供 “必要的” public 方法, 而不应该是把所有的方法都无脑设为 public.

在类内使用方法这一块对外使用接口，

这一块我不怎么建议大家使用，因为有很多逻辑上的问题，尤其是对于初学者，这些省事的方法不好，下面我就简单介绍一下省事的方法把。还是alt+ins键之后选择 getter或者setter 然后选择你需要对外使用的接口即可。—再次强调，不建议使用

main方法为什么要使用static呢？

首先我们知道，不用static便需要在main 执行前对main进行开辟空间。而main又是程序首先执行的，我们想想都矛盾啊。是不是，

this 的使用

this有三种方法，下面我介绍一种：看一下代码

    class Person{
    
    
       public  String name;
       public  void setName(String name){
    
    
           name = name;
       }

       
    }
    public class Test{
    
    
        public static void main(String[] args) {
    
    
            Person p = new Person();
            p.setName("Weiran");
            System.out.println(p.name);
        }

大家猜猜这一块代码的执行结果是多少呀！！毫无疑问，是Weiran。哎！！其实没有疑问归没有疑问，对不对看运行结果把！
在这里插入图片描述
哇哦最后的结果居然是null 为什么呢？听我解释把，。是因为局部变量优先。那么我们如何杜绝这个呢？我们在第一个name前面加一个this.即可

大家看这样就没问题了。在这里，我就不说this的用法了，我相信，只要你比我聪明你就能理解this的用法了。

构造方法

1.如果类中没有提供任何的构造函数，那么编译器会默认生成一个不带有参数的构造函数
2.若类中定义了构造方法，则默认的无参构造将不再生成.
3.构造方法支持重载. 规则和普通方法的重载一致
以上三点给大家介绍，系统会自带一个构造函数，但是，构造函数内什么都没有。而第二点定义构造函数的方法是什么呢？
在这里插入图片描述
看到没有，构造函数的使用，实在类实例化的时候就已经执行了滴！！
当然构造方法也是方法也有参数。那么他就支持重载这里无需多言。

代码块

普通代码块

普通代码块是定义在方法种的

public class Main{
    
     
 public static void main(String[] args) {
    
     
 {
    
     
 int x = 10 ; 
 System.out.println("x1 = " +x); 
 } 
 int x = 100 ; 
 System.out.println("x2 = " +x); 
 } 
}

直接{}的代码那一块就是普通代码块这种方法很少用，因为用了和没用并没啥区别啊。

构造代码块

构造代码块是在类中，不是构造方法，也叫实例代码块

class Person{
    
     
 private String name;//实例成员变量
 private int age; 
 private String sex; 
 public Person() {
    
     
 System.out.println("I am Person init()!"); 
 } 
 //实例代码块
 {
    
     
 this.name = "bit"; 
 this.age = 12; 
 this.sex = "man"; 
 System.out.println("I am instance init()!"); 
 } 
 public void show(){
    
     
 System.out.println("name: "+name+" age: "+age+" sex: "+sex); 
 } 
} 
public class Main {
    
     
 public static void main(String[] args) {
    
     
 Person p1 = new Person(); 
 p1.show(); 
 } 
}

在方法里构造函数的那一块就是构造代码块。
注意事项: 实例代码块优先于构造函数执行。

静态代码块

 static {
    
     
 count = 10;//只能访问静态数据成员 
 System.out.println("I am static init()!"); 
 }

就像这样直接使用static 定义的代码块就是静态代码块！！
静态代码块优先于实例代码块
其实通过上面的介绍，我相信大家对类与方法这一部分都能有非常深入的理解

匿名对象

匿名只是表示没有名字的对象
注意事项有三点

没有引用的对象称为匿名对象.
匿名对象只能在创建对象时使用.
如果一个对象只是用一次, 后面不需要用了, 可以考虑使用匿名对象.
下面我直接放一个代码把”

class Person {
    
     
 private String name; 
 private int age; 
 public Person(String name,int age) {
    
     
 this.age = age; 
 this.name = name; 
 } 
 public void show() {
    
     
 System.out.println("name:"+name+" " + "age:"+age); 
 } 
} 
public class Main {
    
     
 public static void main(String[] args) {
    
     
 new Person("caocao",19).show();//通过匿名对象调用方法
 } 
}

这就是使用了，配上上面的内容我相信大家都能很容易的理解了，

总结

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

关于小编

小编是一名正在奋斗的大一小骚年，希望能与大家一起学习哦。在编程的路上也希望能有朋友一起学习！！！这篇博客是小编自己理解的写的，所以，有些地方可能有所不足，忘大家给予指点，错的越多后期越吃香。
小编qq号：2206730228
希望能与大家一起学习哦！！！！！！

java核心之类和对象