首先

java是面向对象的，关注的是对象，是将一件事情分成很多不同对象，靠对象与对象之间的交互完成。

类和对象的实例化

类是一类对象的统称，而对象是这一类具体化的一个实例。一个类可以产生多个对象

基本语法

在java中使用关键字class声明类。

//创建类classPerson{//成员变量（也可以说是字段、属性）publicString name;publicintage;publicString sex;//成员方法publicvoideat(){
System.out.println("在吃饭");
}publivoidsleep(){
System.out.println("在睡觉")；
}
}

类的实例化

类的实例化：通过类类型创建对象的过程

类就像模型一样的东西，限定了成员。 类可以在实例化多个对象，对象才能存储实际数据，占用物理内存存储成员属性。

在类的实例化过程中通过关键字new实例化对象；使用 . 可以访问对象属性和方法 ；一个类可以实例化多个对象。

publicclassPerson{//属性publicString name;publicintage;//成员方法publicvoideat(){
System.out.println("吃饭");
}publicstaticvoidmain(String[] args){
Person person1 =newPerson();//通过关键字new实例化对象Person person2 =newPerson();
person.name ="冷";//调用属性需要通过对象引用调用person.age =18;
person1.eat();//调用成员方法需要通过对象引用调用}
}

类的成员

1、字段（属性或变量）在类中但方法的外部成为字段或属性或变量。用来描述一个类中包含哪些数据。

使用 . 访问对象字段；可以对字段进行读写；若一个对象的字段没有进行显式初始化，那么会被设置为默认值。

classPerson{//属性publicString name;publicintage;publicString sex;
}publicclassMain{publicstaticvoidmain(String[] args){
Person person =newPerson();//通过关键字new实例化对象person.name ="冷";
System.out.println(person.name);
System.out.println(person,sex);
System.out.println(person.age);
}
}

类的方法

类的方法用来描述一个对象的行为。此时类的方法不用static修饰。

classPerson{//成员方法publicvoideat(){
System.out.println("吃饭");
}publicvoidshow(){//表示Person对象具有的自我介绍行为System.out.println(name +"今年"+ age +"岁啦~");
}
}publicclassMain{publicstaticvoidmain(String[] args){
Person person =newPerson();//通过关键字new实例化对象person.name ="冷";
person.age =18;
person.show();
}
}

方法中还有一种特殊的方法称为构造方法。

构造方法

构造方法在实例化对象时自动调用该方法

构造方法方法名必须和类名相同构造方法不用声明返回类型每一个类中至少有一个构造方法（当没有明确定义构造方法时，编译器会自动生成一个无参的构造方法；但若定义了构造方法则不会生成无参构造方法；构造方法支持重载）

static关键字

修饰属性同一个类的不同对象共用一个静态属性。在访问static修饰的属性时，访问方法为类名.属性

classTestDemo{publicintx;publicstaticinty;//y被static修饰，属于类本身，只有一份}publicclassTest{publicstaticvoidmain(String[] args){
TestDemo td1 =newTestDemo();
td1.x++;//x没有显式定义，默认为0，x++后，x=1TestDemo.y++;//y=1System.out.println(td1.x);
System.out.println(TestDemo.y);
System.out.println("===========");
TestDemo td2 =newTestDemo();
td2.x++;
TestDemo.y++;//y被static修饰，因此所有类共享 此时y = 1+1;System.out.println(td2.x);
System.out.println(TestDemo.y);
}
}

输出结果：

修饰方法使用static修饰的方法称为静态方法。

静态方法属于类，不属于对象可以直接调用静态方法，不用实例化静态方法可以访问静态成员变量，并对静态成员变量赋值

classTestDemo{publicintx ;publicstaticinty ;//默认y初始值为0publicstaticvoidfunc(){
y =100;//定义静态方法对静态变量赋值，y=100}
}publicclassTest{publicstaticvoidmain(String[] args){
TestDemo.func();
System.out.println(TestDemo.y);
}
}

封装

private实现封装

public和private都表示成员属性访问权限

public修饰的成员变量和方法可以直接被类的调用者使用private修饰的成员变量和方法不可以被调用者使用，需要使用getter/setter方法获取或使用private属性

getter/setter方法

publicclassStudent{privateString name;privateintage;//设置学生姓名publicvoidsetName(String name){this.name = name;//this引用表示调用该方法的对象（this表示当前对象的引用）}//获取学生姓名publicStringgetName(){returnname;
}publicvoidsetAge(intage){this.age = age;
}publicintgetAge(){returnage;
}publicstaticvoidmain(String[] args){
Student student =newStudent();
student.setName("就这");
student.setAge(3);
String sName = student.getName();intsAge = student.getAge();
System.out.println(sName);
System.out.println(sAge);
}
}

this关键字

this表示当前对象的引用，通过借助this可以访问对象的属性和方法

publicclassTeacher{privateString name;privateString sex;privateintage;publicTeacher(){this("啾咪","女",3);//this调用构造函数，必须显式放在第一行}//构造函数重载publicTeacher(String name,String sex,intage){this.name = name;this.age = age;this.sex = sex;
}publicvoidshow(){
System.out.println("name:"+ name+" sex:"+sex+" age:"+age);
}publicstaticvoidmain(String[] args){
Teacher teacher =newTeacher();
teacher.show();
}
}

代码块

字段的初始化除了就地初始化和构造方法初始化外，还有代码块初始化。使用{ }定义的代码称为代码块代码块根据定义位置和关键字可以分为四种：普通代码块、构造代码块、静态代码块和同步代码块

普通代码块定义在方法中的代码块称为普通代码块

构造代码块定义在类中的代码块，不加修饰符

静态代码块使用static关键字定义的代码块。静态代码块不论生成多少对象，都只会执行一次，而且是最先执行的；静态代码块执行完成后，构造代码块执行，再是执行构造函数

toString方法

toString方法是将对象直接转换成字符串

publicclassStudent{privateString name;privateintage;publicStudent(String name ,intage){this.name = name;this.age = age;
}publicvoidshow(){
System.out.println("name:"+name+" age:"+age);
}//重写Object的toString方法@OverridepublicStringtoString(){return"Person{"+"name："+ name ++" age:"+ age +"}";

}publicstaticvoidmain(String[] args){
Student student =newStudent("这就",3);
student.show();
System.out.println(student);//toString方法会在println时自动调用}
}

继承

在生活中，事物与事物之间有一定的关联，因此在创建类时类和类之间也会有一定的关联。就像生活中的猫和狗都有一些动物特有的属性和行为，因此在写代码时猫类和狗类可以继承动物类。

//定义动物类classAnimal{publicString name;publicvoideat(String food){
System.out.println(this.name +"正在吃"+food);
}publicAnimal(String name){this.name = name;
}
}//定义猫类继承动物类classCatextendsAnimal{publicCat(String name){super(name);//使用super调用父类属性}
}//定义狗类继承动物类classDogextendsAnimal{publicDog(String name){super(name);
}
}publicclassTestDemo{publicstaticvoidmain(String[] args){
Cat cat =newCat("猫咪");
cat.eat("猫粮");
Dog dog =newDog("旺柴");
dog.eat("骨头");
}
}

在java中一个子类只能继承一个父类子类会继承父类所有 public 修饰的属性和方法父类中使用 private 修饰的属性和方法，子类是无法访问的子类的实例中，也包含着父类的实例，可以使用 super 关键字引用父类实例

多态

多态表示同一个行为有不同的表现形式。比如动物的叫声这一行为，猫会发出喵的声音，狗会发出汪汪的声音，羊会发出咩的声音。同一个时间发生在不同的对象身上会有不同的行为产生，叫多态

packagefirst;classAnimal{publicvoidvoice(){
}
}classCatextendsAnimal{@Overridepublicvoidvoice(){
System.out.println("喵");
}
}classDogextendsAnimal{@Overridepublicvoidvoice(){
System.out.println("汪汪");
}
}classSheepextendsAnimal{@Overridepublicvoidvoice(){
System.out.println("咩");
}
}publicclassTestDemo{publicstaticvoidmain(String[] args){
Animal animal1 =newCat();
Animal animal2 =newDog();
Animal animal3 =newSheep();
animal1.voice();
animal2.voice();
animal3.voice();
}
}

输出结果：

最后

大家看完有什么不懂的可以在下方留言讨论，也可以关注我私信问我。谢谢你的观看，觉得文章对你有帮助的话记得关注我点个赞支持一下！