首先

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

类和对象的实例化

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

基本语法

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

//创建类
class Person {
    //成员变量（也可以说是字段、属性）
    public String name;
    public int age;
    public String sex;
    //成员方法
    public void eat(){
        System.out.println("在吃饭");
    }
    publi void sleep(){
        System.out.println("在睡觉")；
    }
}

类的实例化

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

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

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

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

类的成员

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

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

class Person {
    //属性
    public String name;
    public int age;
    public String sex;
}
public class Main{
    public static void main(String[] args) {
        Person person = new Person(); //通过关键字new实例化对象
        person.name = "冷";
        System.out.println(person.name);
        System.out.println(person,sex);
        System.out.println(person.age);
    }
}

类的方法

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

class Person {
    //成员方法
    public void eat(){
        System.out.println("吃饭");
    }
    public void show(){
        //表示Person对象具有的“自我介绍”行为
        System.out.println(name + "今年" + age + "岁啦~");
    }
}
public class Main{
    public static void main(String[] args) {
        Person person = new Person(); //通过关键字new实例化对象
        person.name = "冷";
        person.age = 18;
        person.show(); 
    }
}

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

构造方法

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

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

static关键字

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

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

输出结果：

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

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

class TestDemo{
    public int x ;
    public static int y ; //默认y初始值为0
    public static void func(){
        y = 100; //定义静态方法对静态变量赋值，y=100
    }
}
public class Test {
    public static void main(String[] args) {
        TestDemo.func();
        System.out.println(TestDemo.y);
    }
}

封装

private实现封装

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

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

getter/setter方法

public class Student {
    private String name;
    private  int age;
    //设置学生姓名
    public void setName(String name){   
        this.name = name; //this引用表示调用该方法的对象（this表示当前对象的引用）
    }
    //获取学生姓名
    public String getName(){
        return name;
    }

    public void setAge(int age){
        this.age = age;
    }
    public int getAge(){
        return age;
    }

    public static void main(String[] args) {
        Student student = new Student();
        student.setName("就这");
        student.setAge(3);
        String sName = student.getName();
        int sAge = student.getAge();
        System.out.println(sName);
        System.out.println(sAge);
    }
}

this关键字

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

public class Teacher {
    private String name;
    private String sex;
    private int age;

    public Teacher(){
        this("啾咪","女",3); //this调用构造函数，必须显式放在第一行
    }

    //构造函数重载
    public Teacher(String name,String sex,int age){
        this.name = name;
        this.age = age;
        this.sex = sex;
    }
    public void show(){
        System.out.println("name:"+ name+"  sex:"+sex+"  age:"+age);
    }
    public static void main(String[] args) {
        Teacher teacher = new Teacher();
        teacher.show();
    }
}

代码块

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

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

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

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

toString方法

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

public class Student {
    private String name;
    private  int age;

    public Student(String name ,int age){
        this.name = name;
        this.age = age;
    }
    public void show(){
        System.out.println("name:"+name+"  age:" +age);
    }

    //重写Object的toString方法
    @Override
    public String toString(){
        return "Person{"+
                "name：'"  + name + '\'' +
                " age:" + age  +
                "}";

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

继承

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

//定义动物类
class Animal {
    public String name;
    public void eat(String food){
        System.out.println(this.name +"正在吃"+food);
    }
    public Animal(String name){
        this.name = name;
    }
}
//定义猫类继承动物类
class Cat extends Animal{
    public Cat(String name){
        super(name); //使用super调用父类属性
    }
}
//定义狗类继承动物类
class Dog extends Animal{
    public Dog(String name){
        super(name);
    }
}

public class TestDemo{
    public static void main(String[] args) {
        Cat cat = new Cat("猫咪");
        cat.eat("猫粮");
        Dog dog = new Dog("旺柴");
        dog.eat("骨头");
    }
}

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

多态

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

package first;

class Animal {
    public void voice(){
    }
}

class Cat extends Animal{
    @Override
    public void voice(){
        System.out.println("喵");
    }
}
class Dog extends Animal{ 
    @Override
    public void voice(){
        System.out.println("汪汪");
    }
}
class Sheep extends Animal{
    @Override
    public void voice(){
        System.out.println("咩");
    }
}

public class TestDemo{
    public static void main(String[] args) {
        Animal animal1 = new Cat();
        Animal animal2 = new Dog();
        Animal animal3 = new Sheep();
        animal1.voice();
        animal2.voice();
        animal3.voice();
    }
}

输出结果：

最后

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