java初识：类和对象

java初识：类和对象

一、类和对象的初步认知

咱们先来说一说对象（此对象非彼对象）😉😉😉😉

在学习语言的时候常常听说面对过程，面对对象，什么是面对过程，什么是面对对象尼？

面向过程：

注重的是过程，在整个过程中所涉及的行为，就是功能 。

举个列子：

（此图来源于漫画） 漫画链接：

配这张图更通俗易懂说明面对过程是注重过程的，一个步骤一个步骤解析，最后解决问题。

C语言就是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题 。

面对对象：

注重的是对象，也就是参与过程所涉及到的主体。是通过逻辑将一个个功能实现连接起来

来个例子看看：

（此图来源于漫画） 漫画链接：

JAVA是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成

【面向对象设计】
面向对象设计把握一个重要的经验：谁拥有数据，谁对外提供操作这些数据（私有）的方法！（被动的一方是数据的拥有者，主动的一方是执行者 ）

【开发时】

首先要思考：先找对象，创建对象，使用对象，并维护对象之间的关系

简而言之
面向对象就是用代码(类)来描述客观世界的事物的一种方式. 一个类主要包含一个事物的属性和行为

下面进入正题：

二、类的成员和类的实例化

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

总的来说：类相当于一个模板，对象是由模板产生的样本。一个类，可以产生无数的对象

基本语法：

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

class为定义类的关键字，Class_Name为类的名字，{}中为类的主体 。

类中的元素称为：成员属性，属性就是成员变量->定义在类中，方法外的变量。类中的函数称为：成员方法。

示例：

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

2.1 类的实例化

用类类型创建对象的过程，称为类的实例化

实例化一个对象需要分两步：

1、为对象分配内存

2、调用合适的构造方法（构造方法不止一个）；

用法：

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

实例：

class Person {
   public int age;//成员属性 
   public String name;
   public String sex;
    
    public void eat() {
        //成员方法
      System.out.println("吃饭!");
 }
}
public class main{
    public static void main(String[] args) {
        Person ps=new Person();//通过new实例化对象
        
        Person ps1=new Person();//可以有多个对象
        Person ps2=new Person();
        Person ps3=new Person();
        Person ps4=new Person();   
    }
}

通过引用访问成员变量和成员方法：

class Person {
   public int age;//成员属性 
   public String name;
   public String sex;
    
    public void eat() {
        //成员方法
      System.out.println("吃饭!");
 }
public class main{
    public static void main(String[] args) {
        Person ps=new Person();//通过new实例化对象
        ps.eat();//成员方法调用需要通过对象引用调用
        
        ps.age="***";//通过对应的引用使用点号来访问，                        并初始化
        ps.name="***";
        ps.sex="**";

综上所述：

1.如何定义一个类

2.类当中需要要成员变量和成员方法

3.通过对象应用如何访问成员变量和成员方法

4.如何通过类实例化对象

5.实例化对象之后，对象在堆上

通过上面代码，这五个问题都可以迎刃而解。

注意事项：

1.new关键字用于创建一个对象的实例

2.使用 . 来访问对象中的属性和方法

3.同一个类可以创建多个对象

补充：

一、数据类型分为两部分：1.基本/内置类型/简单类型：整数，小数，字符

​ 2.引用类型：字符串，数组，类，接口，枚举（引用类型都会有引用变量，引用变量存储的是地址）

二、属性也可称之为字段。

三、对于一个对象的字段如果没有显式设置初始值, 那么会被设置一个默认的初值

默认规则：

1.引用类型默认为null，

2.基本类型默认对应0值，

3.boolean默认false

4.char默认’\u0000’

认识null

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

class Person {
    public int age;//成员属性
    public String name;
    public String sex;

    public void eat() {
        //成员方法
        System.out.println("吃饭!");
    }
}
public class dome2 {
    public static void main(String[] args) {
        Person ps=null;
        System.out.println(ps.sex);//会发生空指针异常
        ps.eat();

    }
}

或者：

public class dome2 {
    public static void main(String[] args) {
        Person ps=null;
        System.out.println(ps.sex.length());
        //也是会发生控制住异常
    }
}

2.2 static

之前讲到了成员变量，成员变量也分 普通成员变量 和 静态成员变量，成员方法也是分 普通成员方法 和 静态成员方法

1.修饰属性

2.修饰方法

3.代码块

1.修饰属性：Java静态属性和类相关, 和具体的实例无关. 换句话说, 同一个类的不同实例共用同一个静态属性

count被static所修饰，所有类共享。且不属于对象，访问方式为：类名 . 属性 。

2.修饰方法：

如果在任何方法上应用 static 关键字，此方法称为静态方法。
（1）.静态方法属于类，而不属于类的对象。
（2）.可以直接调用静态方法，而无需创建类的实例。
（3）. 静态方法可以访问静态数据成员，并可以更改静态数据成员的值 .

class TestDemo {
    public int a;
    public static int count;
    public static void func() {
        count=100;
    }
}
public class dome2 {
    public static void main(String[] args) {
       TestDemo.func();//无需创造实例对象就可以调用
        //相反若果是普通成员变量就要创造实例对象，再通过引用变量调用
        System.out.println(TestDemo.count);
    }
}

总结：普通方法的调用，需要依赖对象。静态方法不依赖对象

三、封装

3.1 private

private/ public 区别：

两个关键字都是这两个关键字表示 “访问权限控制”

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

3.2getter和setter方法

getter和setter：当用private修饰成员的时候，若要获取或者修改这个private属性，就要用到getter/setter

用法：

class TestDemo {
    private int age;//也被privat修饰，类的调用者(main方法中)不能直接使用，需要借助getter和setter方法
    private String name;

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;//this代表当前对象的引用
        //name=name;不能这么用，这属于局部变量，出现的name都是这个方法的name
    }
    //为什么会使用getter和setter？需要借助getter和setter方法无需在意类中内部情况，效率高，如果用public类的调用者直接使用要跟进TestDemo类中内部的实现，效率不高。
}
public class dome2 {
    public static void main(String[] args) {
       TestDemo td=new TestDemo();
       td.setName("123");
       String ret =td.getName();
        System.out.println(ret);
    }
}

如果改成了

 public void setName(String name) {
        name = name;
 }//会报错

局部变量里面两个name都是这个局部变量里面的，所以要加上this

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

getName 即为 getter 方法, 表示获取这个成员的值 ；

setName 即为 setter 方法, 表示设置这个成员的值.

四、构造方法

4.1基本用法：

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

类都有构造方法。

实例化对象分两步：

1. 为对象分配内存
2. 调用合适的构造方法（构造方法不止一个）

语法规则
1.方法名称必须与类名称相同
2.构造方法没有返回值类型声明
3.每一个类中一定至少存在一个构造方法（没有明确定义，则系统自动生成一个无参构造 )

class TestDemo {//方法名称必须与类名称相同
    private int age;
    private String name;
    /*public TestDemo () {
        System.out.println("");
    }*/
}
public class dome2 {
    public static void main(String[] args) {
       TestDemo td=new TestDemo();
    }
}

编译器不会报错，当前类中没有提供任何构造方法的时候，编译器会默认提供一个不带参数的构造方法，一旦你手动提供了构造方法，编译器不在提供默认提供一个不带参数的构造方法。

class TestDemo {
    private int age;
    private String name;
    public TestDemo () {
        System.out.println("");//不带参数
    }
    public  TestDemo(String name) {
        this.name=name;//一个参数
    }
    public  TestDemo(String name,int age) {
        this.name=name;
        this.age=age;
       //两个参数
    }
}
public class dome2 {
    public static void main(String[] args) {
       TestDemo td=new TestDemo();
       TestDemo td1=new TestDemo("某某");
       TestDemo td2=new TestDemo("某某“, 18);
    }
}

用到 了重载。

重载的规则：

针对同一个类：

1、方法名相同

2、方法的参数不同(参数个数或者参数类型)

3、方法的返回值类型不影响重载

注意事项
1.如果类中没有提供任何的构造函数，那么编译器会默认生成一个不带有参

2.数的构造函数
3.若类中定义了构造方法，则默认的无参构造将不再生成.
4.构造方法支持重载. 规则和普通方法的重载一致

5、构造方法不仅仅可以构造对象，同事也可以帮助我们进行成员变脸的初始化

4.3 this关键字

例子可以看 目录 3.1

this . 成员变量

this . 成员属性

this（）调用其他的构造方法

问题：为什么this是代表当前对象的引用，而不是代表当前对象？

实例化对象需要分两步，1.为对象分配内存。 2.调用合适的构造方法（构造方法不止一个），两部完了才产生当前对象

 public  TestDemo(String name) {
        this.name=name;
    }//这里面this还在构造方法里面，还没有产生当前对象

在静态方法里面不能出现this，this与对象挂钩，静态跟对象没关系。

五、toString

class TestDemo {
    public int age;
    public String name;
    public void show() {//这个叫做show方法，表示这个对象的自我展示行为
        System.out.println("我叫" + name + ", 今年" + age + "岁");
    }
} 

但是每次写show方法效率不高所以就有了toString。如果没申请toString就会打印一串地址。

class TestDemo {
    public int age;
    public String name;
    public void show() {
        System.out.println("我叫" + name + ", 今年" + age + "岁");
    }
}
public class dome2 {
    public static void main(String[] args) {
       TestDemo td=new TestDemo();
        System.out.println(td);
    }
}

重写toString方法：

class TestDemo {
    public int age;
    public String name;
    public void show() {
        System.out.println("我叫" + name + ", 今年" + age + "岁");
    }
    @Override//注释   重写的方法
    public String toString() {
        return "TestDemo{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}
public class dome2 {
    public static void main(String[] args) {
       TestDemo td=new TestDemo();
        System.out.println(td);
    }
}

这样变量td就会重新调用toString方法，就可以打印值了