坚信自己，人生往往柳暗花明。
----DJ懒洋洋
一:类 对象
类（class）和对象 (object)是两种以计算机为载体的计算机语言的合称。 对象是对客观事物的抽象，类是对对象的抽象。 类是一种抽象的数据类型。 它们的关系是，对象是类的实例，类是对象的模板。在java中，所有的一切皆可对象，即对象的属性和行为由类进行组织，类产生对象。
关系图如图所示:
1):那么，java语言当中该如何创建类呢?
上图是对类的定义做个总结，接下来我们来看代码:
//ClassName--->即类型，遵循大驼峰的命名方式 class ClassName{ //fields---->字段:描述成员属性 //method--->方法:描述成员行为 } //以学生类为例 class Student{ public String name; public int age; public void eat(){ System.out.printli("好好学习，天天向上") } }
2):如何实例化对象
以学生为例，实例化对象，关键字:new,我们通过一张图来看一下。
代码实现:
class test1{ public static void main(String[] args) { Student student =new Student(); Student student1=new Student(); System.out.println(student); System.out.println(student1); } }
如何调用创建对象的方法呢?进行解应用，关键符号:.
student.study();
运行结果:
3):this关键字的使用
this:代表当前对象进行使用。我们来看如下代码，看看会发生哪些错误:
注意： this(...)必须是构造方法中第一条语句
class TestDate{ //成员属性 public int day; public int month; public int year; //成员行为 public void setDate(int day,int month,int year){ //此时参数和成员变量的命名相同 day=day; month=month; year=year; } public void printDate(){ System.out.println("年:"+year+"月:"+month+"日:"+day); } } class test2{ public static void main(String[] args) { TestDate date=new TestDate(); date.setDate(10,10,2022); date.printDate(); } } //从代码来看，是要将年月日进行打印。即打印的为2022年10月10日
代码运行如下:
结果并不如我们预期那样，会打印2022年10月10日，而是0年0月0日，在java当中，当我们创建类时，成员行为中，局部变量高于成员变量，即在setDate这个成员行为中，局部变量year,month,day是在给自己赋值，等到这个成员行为结束后，局部变量的值被释放掉，而成员变量自始至终都没有赋值，即还是0.
那么，我们加入this关键字，能不能解决这一问题呢?
class TestDate{ //成员属性 public int day; public int month; public int year; //成员行为 public void setDate(int day,int month,int year){ //此时参数和成员变量的命名相同 this.day=day; this.month=month; this.year=year; } public void printDate(){ System.out.println("年:"+year+"月:"+month+"日:"+day); } } class test2{ public static void main(String[] args) { TestDate date=new TestDate(); date.setDate(10,10,2022); date.printDate(); } }
运行效果:
可见，this关键字可以解决这一问题，即通过this关键字可以告诉编译器当前是哪个对象在调用成员属性和成员行为。
this的特性:
4):构造方法
作用:对对象的各个属性进行初始化。
//如何进行构造 权限修饰符 +类名 (参数列表){}
public class Animal { public String name; public int age; public Animal(){ //空参构造 } public Animal(String name,int age){ this.name=name; this.age=age; } public void print(){ System.out.println("动物的姓名:"+this.name+"动物的年龄:"+this.age); } } class test{ public static void main(String[] args) { Animal animal=new Animal();//空参构造的实例化 Animal animal1=new Animal("小狗",18); animal.print(); animal1.print(); } }
可见，在空参构造时，所有的成员属性均被初始化，即String类型的引用变量赋值为null，int类型的为0,在实参构造中，我们对成员变量进行了赋值，此时，所对应的各个属性均有了我们想要赋的值。同时，空参构造和实参构造属于java里面的方法重载。
方法重载:
1:方法名相同
2:参数列表不同(参数类型不同，参数列表不同)
3:返回值类型不做要求。
此外，空参构造是默认的，即不写也可以完成空参构造，但当写实参构造时，空参构造就不是默认的，需要我们进行手动添加。
5):默认初始化
在java中，如果在main函数中，变量不进行赋值，会报错，但是，在类中，如果我们不对成员变量进行赋值，那么，会有默认对应的初始化值，如下图所示:
二:封装
1):封装的概念:
在java当中，如果自己实现的内部细节不想被别人看见，我们就可以进行封装，即套壳屏蔽细节。将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互。
关键字:private,即私有化成员变量。在此之前，我们先了解访问权限修饰符。每个修饰符对应的使用权限。
在封装中，我们使用的是private关键字，即别人不能看见成员属性和成员行为的细节，即只能在同一包中的同一类进行使用。那么，如果，我们进行了封装，想要用，怎么办?这时候，我们可以用public访问权限修饰符，对其私有化的成员变量进行赋值和访问。
代码如下:
public class Person { private String name; private int age; private String id; public Person() { } public Person(String name, int age, String id) { this.name = name; this.age = age; this.id = id; } 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 String getId() { return id; } public void setId(String id) { this.id = id; } } class test3{ public static void main(String[] args) { Person person=new Person(); person.setName("李华"); person.setAge(18); person.setId("1"); System.out.println("姓名:"+person.getName()+" 年龄:"+person.getAge()+" 编号"+person.getId()); } }
运行结果:
2):static关键字
static关键字是java中较为重要的关键字，即可以修饰成员变量和成员方法。
static修饰成员变量:---->假设:我们创建了三个学生对象，而三个学生恰好在一个教室里，这时候我们就可以使用static关键字来减少代码的使用。
代码如下:
public class Student { private String name; private int age; private int id; public static String classRoom="301"; public Student() { } public Student(String name, int age, int id) { this.name = name; this.age = age; this.id = id; } public String getName() { return name; } public Student setName(String name) { this.name = name; return this; } public int getAge() { return age; } public Student setAge(int age) { this.age = age; return this; } public int getId() { return id; } public Student setId(int id) { this.id = id; return this; } public static String getClassRoom() { return classRoom; } public static void setClassRoom(String classRoom) { Student.classRoom = classRoom; } @Override public String toString() { return "Student{" + "name='" + name + '\'' + ", age=" + age + ", id=" + id + '}'; } } class test4{ public static void main(String[] args) { Student student=new Student("小李",18,1); System.out.println(student); Student student1=new Student("小华",19,2); System.out.println(student1); Student student2=new Student("小明",18,3); System.out.println(student2); //调用类里面的静态成员变量 System.out.println(Student.classRoom); } }
由上述代码可知，静态成员变量需要用类名.静态成员变量来使用。Java中，被static修饰的成员方法称为静态成员方法，是类的方法，不是某个对象所特有的，因此，成员方法也需要通过类名.成员方法来使用。
【静态方法特性】
1. 不属于某个具体的对象，是类方法
2. 可以通过对象调用，也可以通过类名.静态方法名(...)方式调用，更推荐使用后者
3. 不能在静态方法中访问任何非静态成员变量
欢迎各位大佬前来批评指正。谢谢大家
