面向对象编程

什么是面向对象

• 面对对象编程（Object-Oriented Programming, OOP）
• 面向对象编程的本质就是：以类的方式组织代码，以对象的组织（封装）数据

三大特性

1. 封装
2. 继承
3. 多态

静态方法 static

非静态方法

public class Main {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person.name);
        Main.change(person) ;
        System.out.println(person.name);
    }
    public static void change(Person person){
        person.name="xlx" ;
    }
}
class Person{
    String name ;
}

类和对象的关系

public class Main {
    public static void main(String[] args) {
        Student xiaoming = new Student() ;
        System.out.println(xiaoming.name);
        xiaoming.name="xiaoming" ;
        System.out.println(xiaoming.name);
    }

}
class Student{
    String name ;
    int age ;
    public void study(){
        System.out.println(this.name + "在学习");
    }
}

创建和初始化对象

一个类即使什么都不写，它也会存在一个方法

简单内存分析

封装

public class Main {
        public static void main(String[] args) {
            Student s1 = new Student() ;
            //get 获得这个数据
            //set 给这个数据设置值
            s1.setName("xlx");
            System.out.println(s1.getName());
            s1.setAge(999);
            System.out.println(s1.getAge());
    }

}
class Student{
    private String name ; //名字
    private int id ; //学号
    private char sex ; //性别 
    private int age ;
    public String getName(){
        return this.name;
    }
    public void setName(String name){
        this.name = name ;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if(age > 120 || age < 0)
        {
            this.age = 3 ;
        }
        else {
            this.age = age;
        }
    }
}

继承

私有的东西无法被继承

super注意点:

1. super调用父类的构造方法，必须再构造方法中的第一个
2. super 必须出现在子类的方法或者构造方法中
3. super和this不能同事调用构造方法
   

重写：需要有继承关系，子类重写父类的方法！

多态

instanceof （类型转换） 引用类型，判断一个对象是什么类型~

static

package xlx.x;

public class Student {
    private static int age;
    private double score;
    public static void main(String[] args) {
        Student s1 = new Student() ;
        System.out.println(Student.age);
        //System.out.println(Student.score); 报错
        System.out.println(s1.age);
        System.out.println(s1.score);
    }
}

package xlx.x;

public class Student {
    //2
    {
        //匿名代码块
        System.out.println("xlx");
    }
    // 1
    static // 只执行一次
    {
        //静态代码块
        System.out.println("hyy");
    }

    // 3
    public Student()
    {
        System.out.println("xlx hyy");
    }

    public static void main(String[] args) {
        Student person = new Student();
        System.out.println("===========");
        Student s2 = new Student() ;
    }
}

package xlx.x;

import static java.lang.Math.random;
import static java.lang.Math.PI;

public class Test {
    public static void main(String[] args) {
        System.out.println(random());
        System.out.println(PI);
    }
}

抽象类 （abstract）

package xlx.x;

public abstract class Test {
    public static void main(String[] args) {

    }
    public abstract void doSomething();//abstract 抽象方法，只有方法名字，没有方法的实现！
}

package xlx.x;

public class d extends Test{
    public void doSomething()
    {
        
    }
}

接口

声明接口的关键字是 interface

package xlx.demo1;

public interface UserService {
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}

package xlx.demo1;

public class UserServiceImpl implements UserService {
    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void query(String name) {

    }

}

内部类