类和方法知识点

1. 面对对象与面向过程的初步认识

在了解类和方法之前，我们首先要知道面向对象与面向过程的不同之处：

面向对象：是解决问题的一种思想，主要依靠对象之间的交互完成一件事情。

面向过程：它关注的是问题的解决过程，强调将问题分解为一系列的步骤和函数，并且以这些步骤的顺序执行来解决问题。

看定义看不懂？没事，接着往下看—>

在洗衣服的过程中，传统方式就是:

而且少一步都不行，这就和面向过程是异曲同工的。

但有了洗衣机后，那就不同了->

对于使用洗衣机的人，是不需要关注洗衣机是如何把衣服洗干净，如何甩干等等。这样的思想就和面向对象是相似的呦！

2.类的定义与使用

在此基础上，便引出类是用来对一个实体(对象)来进行描述的。这样的描述才能让计算机能够识别到那个实体。

2.1类的定义格式

在java中定义类时需要用到class关键字，具体语法如下

// 创建类
class ClassName{

field;
method;	// 字段(属性) 或者 成员变量
// 行为 或者 成员方法
}

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

定义一个宠物狗PetDog类

class PetDog {
// 狗的属性
public String name;//名字
public String color;//颜色

// 狗的行为(定义的方法)
public void barks() {
System.out.println(name + ": 旺旺旺~~~");
} 

public void wag() {
System.out.println(name + ": 摇尾巴~~~");
}
}

​

看到这里我们定义了一个类，就相当于在计算机中定义了一种新的类型，与int，double类似，只不过int和double是java语言自带的内置类型，而类是用户自定义了一个新的类型。但我们要如何具体使用呢？请接着看呦~

2.2类的实例化使用

用类这个类型创建对象的过程，称为类的实例化，在java中采用new关键字，配合类名来实例化对象。

做个比方。类实例化出对象就像现实中使用建筑设计图建造出房子，类就像是设计图，只设计出需要什么东西，但是并没有实体的建筑存在，同样类也只是一个设计，实例化出的对象才能实际存储数据，占用物理空间。我们还是引用之前的宠物狗PetDog类

注意：1.图中的dogh是自己命名的。格式就是

 类名 对象名= new 类名();

2.使用 . 来访问对象中的属性和方法，而且同一个类可以创建多个实例.

3.this引用

this引用指向当前对象(成员方法运行时调用该成员方法的对象)，在成员方法中所有成员变量的操作，都是通过该引用去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成。那this的作用是啥呢？

首先看看以下定义的一个方法

public class Date {
public int year;
public int month;
public int day

public void setDate(int year,int month,int day){
    year=year;
    month=month;
    day=day;
}
}

输入后结果却是0值，这就是因为方法中局部变量会优先使用，会在栈中另外开辟空间，这样输入的值就不会改变对象的year month day，而this的作用就有了,便指向了当前对象的引用，这样就不会赋值错位置了~

​
public class Date {
public int year;
public int month;
public int day

public void setDate(int year,int month,int day){
    this.year=year;
    this.month=month;
    this.day=day;
}
}

​

而且this是“成员方法”第一个隐藏的参数，编译器会自动传递，在成员方法执行时，编译器会负责将调用成员方法
对象的引用传递给该成员方法，this负责来接收

4.对象的构造和初始化

public class test {
    static class PetDog {
        public String name;
        public String color;

        public void barks() {
            System.out.println(name + " 汪汪汪");
        }

        public void wags() {
            System.out.println(name + " 摇尾巴");
        }
        public PetDog(){//这里就没有void了
            System.out.println("PetDog被调用了");
        }
    }
    public static void main(String[] args) {
        PetDog dogh = new PetDog(); // 直接实例化 PetDog类的对象
        dogh.color = "黑黄";
        dogh.name = "大黄";
        dogh.barks();
        dogh.wags();
    }
}

首先观察这段代码，我构造了一个不一样的方法PetDog，名字却和类名是一样的，并且我在后面并未调用，但是它却可以自动调用，这就是构造方法的好处。并且成员变量没有初始化也没有关系，因为是有默认值的-->

数据类型	默认值
byte	0
char	'\u0000'
short	0
int	0
long	0L
boolean	false
float	0.0f
double	0.0
reference	null

5.封装

看到这个标题，所以什么事封装呢？-------->简单来说就是套壳屏蔽细节

对于面向对象的语言是有这三大特性：封装，继承，多态。

我们先学习封装，而Java是如何实现的呢？----->访问限定符

在Java中，访问限定符用于控制类、变量、方法和构造函数的可访问性。Java提供了四个访问限定符：

1. public（公共）：被`public`修饰的类、变量、方法和构造函数可以在任何地方被访问，包括其他类、不同包的类以及其他项目中的类。

2. protected（受保护的）：被`protected`修饰的类、变量、方法和构造函数对于同一个包中的其他类是可见的，同时也对于该类的子类是可见的,主要用于继承。

3. default（默认，无修饰符）：如果没有显式指定访问限定符，默认情况下类、变量、方法和构造函数具有默认访问级别。被默认访问修饰的类、变量、方法和构造函数可以在同一个包中访问，但对于不同包中的类则不可见。

4. private（私有的：被`private`修饰的类、变量、方法和构造函数只能在同一个类中被访问，对于其他类和包都是不可见的。

public class MyClass {
    public int publicVariable;
    default int defaultVariable; // 默认访问级别(通常省略default)
    private String privateVariable;
    
    public void publicMethod() {
        // 可以被任何类访问
    }

     default void defaultMethod() {
        // 只能被同一个包中的类访问
    }

    private void privateMethod() {
        // 只能被同一个类中的其他方法访问
    }
}

6.包

什么是包呢？--->为了更好的管理类，把多个类收集在一起成为一组，称为软件包

注意包名的书写：1.全部都是小写

2.域名的逆置写法 ：www.baidu.com-->com.baidu.www

当然，这是咱们自定义包是要注意的！那我们要如何使用Java自带的包呢？

通过 ​import​关键字可以导入其他包中的类和接口，以在当前文件中使用这些类和接口。形式为 ​

import 包名.ClassName;​。

一个小技巧：如果需要使用 某个包中如：java.util 中的其他类, 可以使用 import java.util.*

用*代表所有，因为Java中是用到谁才会导入谁，不过不同包中要是名字有一样的类，那还是老老实实按照格式写，避免冲突嘛~

7.static的用法

7.1 static修饰成员变量

注意：static修饰的color就已经变得不再依赖对象了，是所有成员共享的，因此static不需要对象就能访问，用类名访问即可。

7.2 static修饰成员方法

static修饰成员方法时，这个方法不依赖于类的实例。可以直接通过类名来调用静态方法，而不需要创建类的对象。静态方法不能访问非静态的成员变量，只能访问静态成员变量。

public class test {
    static class PetDog {
        public static String name;//静态方法只能访问静态成员变量，无法直接访问非静态成员变量。
        public String color;

        public static void barks() {
            System.out.println(name + " 汪汪汪");
        }
        public void wags() {
            System.out.println(name + " 摇尾巴");
        }
    }
    public static void main(String[] args) {
        PetDog dogh = new PetDog(); // 直接实例化 PetDog类的对象
        dogh.color = "黑黄";
        PetDog.name = "大黄";
        PetDog.barks();//静态访问
        dogh.wags();//非静态访问，通过对象访问

    }
}

如果需要在静态方法中使用非静态变量，可以通过创建类的对象来实现间接访问

​

    static class PetDog {
        public static String name="大黄";
        public static String getName() {//不能直接访问，创一个新的访问
            return name;
}
        
public static void main(String[] args) {
        System.out.println(PetDog.getName());
    }
}

​

注意：既然我们不需要对象就能调用，那么1.在静态方法中，直接传递一个需要对象的，那肯定不行的，所以是不能传递this的，不过可以间接，创一个新的对象访问

2.反过来，在依赖对象的方法中，却是可以调用静态方法的。

  今天的类和方法就总结到这里，希望大家收获多多，大家也要记得去实践哦~