Java面向对象编程（笔记）

面向对象编程(Object-Oriented Programming.OOP)

Java的核心思想就是面向对象编程

面向对象编程的本质是：以类的方式组织代码。以对象的组织封装数据

面向对象三大特征：

• 封装
• 继承
• 多态

从认识论角度考虑是先有对象后有类。对象是具体的事物。类是抽象的，是对对象的抽象

从代码运行的角度考虑是先有类后有对象。类是对象的模板

类与对象的关系

类是一种抽象的数据类型，它是对某一类事物整体描述/定义，但是并不能代表某一个具体的事物

对象是抽象概念的具体实例

• 能够体现出特点，展现出功能的是具体的实例，而不是一个抽象的概念

使用new关键字来创建对象

使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用

类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下两个特点：

• 必须和类的名字相同
• 必须没有返回类型，也不能写void

//学生类
//类中只可能存在属性和方法
public class Student {
    //属性：字段
    String name;
    int age;

    //方法：行为
    public void study(){
        //this指的是本类的
        System.out.println(this.name+"在学习");

    }

}

//一个项目应该只有一个main方法
//一个类中最多只能有一个main方法
public class Application {
    public static void main(String[] args) {
    //类是抽象的，可以通过new实例化
    //类实例化会返回一个对象，对象就是这个被new类的具体实例
        Student xiaoming = new Student();
        Student xiaohong  = new Student();

        xiaoming.name = "小明";
        xiaoming.age = 13;

        System.out.println(xiaoming.name);
        System.out.println(xiaoming.age);

        xiaohong.name = "小红";
        xiaohong.age = 13;

        System.out.println(xiaohong.name);
        System.out.println(xiaohong.age);

        //类是抽象的，可以通过实例去具体实现
        //上边的代码中，new的是同一个类却得到两个具体的实例
    }

}

小结

• 类与对象：类是一个模板（抽象），对象是一个具体的实例
• 对象的应用：引用类型（除八大基本类型外的），对象是通过引用来操作的
• 属性：字段，成员变量
• 对象的创建和使用：必须使用new关键字创建对象，构造器；对象的属性；对象的方法
• 类：静态的属性 属性；动态的行为 方法

封装

• 封装使程序更加安全更加方便，也可以保护数据
• 隐藏代码的实现细节
• 统一接口，提高了代码的规范
• 系统的可维护性增加了

我们程序设计要追求“高内聚，低耦合”。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合就是仅暴露少量的方法给外部使用

封装： （隐藏的数据） 通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称之为信息隐藏

public class Student {
    //封装主要是针对属性
    //private私有的,只有本类可以访问到
    private String name;
    private int id;
    private char sex;
    private int age;

    public int getAge() {
        return age;
    }
//封装可以限制数据，比如年龄不可能为负数，可以在set方法里设置范围
    public void setAge(int age) {
        if (age>100 || age<0){
            System.out.println("还是人嘛？");
        }else {
            this.age = age;
        }

    }
//通过get，set方法别的类也可以访问到这些属性


    public String getName() {
        return 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 class Application {
    public static void main(String[] args) {
        Student student = new Student();
        student.setName("张三"); //通过set方法设置值
        String name = student.getName(); //通过get方法获取值
        System.out.println(name); //张三

        student.setAge(100);
        int age = student.getAge();
        System.out.println(age);
    }
}

继承

• 继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模
• extends的意思是“扩展”。子类是父类的扩展。
• Java中只有单继承，没有多继承
• 继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等
• 继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示
• 子类和父类之间，从意义上讲应该具有“is a”的关系

//父类
//在Java中所有的类，都默认直接或间接继承object
public class Person {
    public int money = 10_0000_0000;
    public void say(){
        System.out.println("说话");
    }
}

//子类
//子类继承了父类，就会拥有父类的全部方法。
// 前提是父类方法的修饰符是public，如果是privte私有的子类就不能直接使用
public class Student extends Person {
}

//子类
public class Teacher extends Person {
}

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

        Student student = new Student();
        student.say();//子类可以调用父类的方法
        System.out.println(student.money);//1000000000
    }
}

Super

• super调用父类的构造方法，必须在构造方法的第一个
• super必须只能出现在子类的方法或者构造方法中
• super和this不能同时调用构造方法

super和this

代表对象不同：

• this：本身调用这个对象
• super：代表父类的应用

前提：

• this：没有继承也可以使用
• super：只能在继承条件下才可以使用

构造方法：

• this：本类的构造
• super：父类的构造

public class Person {
    //父类私有的属性和方法子类可以继承但不能被访问
    public String name = "zhangsan";
    public void print(){
        System.out.println("Person");
    }

    public Person() {
        System.out.println("Person无参执行了");
    }
}

public class Student extends Person {
    private String name = "lisi";
    public void print(){
        System.out.println("Student");
    }
    //在子类的内部调用父类的方法和属性是通过super来实现的
    public void test1(){
       print(); //Student
       this.print(); //Student
       super.print(); //Person
    }

    public void test(String name){
        System.out.println(name); //输出方法里边的name
        System.out.println(this.name);//输出本类的name
        System.out.println(super.name);//输出父类的name
    }

    public Student() {
        //隐藏代码：super调用了父类的构造器，而且必须要在子类构造器的第一行
        super();//this和super只能有一个而且必须在第一行
        System.out.println("Student无参方法执行了");
    }
}

public class Appliction {
    public static void main(String[] args) {
        Student student = new Student();
        System.out.println("=====================");
        student.test("王五");
        System.out.println("=======================");
        student.test1();
    }
}

方法的重写

重写发生在继承关系中，子类重写父类的方法

重写都是方法的重写，和属性无关

重写和静态的方法无关，只能重写非静态的方法

父类的方法修饰符只要不是private都可以重写

子类的方法和父类的方法必须要一致，方法体不同

• 方法名必须相同
• 参数列表必须相同
• 修饰符的范围可以扩大，但不能缩小
• public>protected>default(默认的)>private
• 抛出的异常范围，可以被缩小，但不能扩大

为什么要重写

• 父类的功能，子类不一定需要，或者不一定满足

public class B {
    public static void test(){
        System.out.println("B-test");
    }
    public void test1(){
        System.out.println("B类非静态的");
    }
}

public class A extends B {
    public static void test(){
        System.out.println("A-test");
    }

    @Override//重写
    public void test1(){
        System.out.println("A类非静态的");
    }
}

/*静态的方法可以被继承，但是不能重写。
如果父类中有一个静态的方法，子类也有一个与其方法名，
参数类型，参数个数都一样的方法，并且也有static关键字修饰，
那么该子类的方法会把原来继承过来的父类的方法隐藏，而不是重写。
通俗的讲就是父类的方法和子类的方法是两个没有关系的方法，
具体调用哪一个方法是看是哪个对象的引用；
这种父子类方法不在存在多态的性质。*/
public class Appliction {
    public static void main(String[] args) {
        //方法的调用只和左边，定义的数据类型有关
        A a = new A();
        a.test();//A-test
        //父类的引用指向了子类
        B b = new A();
        b.test();//B-test

        //方法重写了
        a.test1();//A类非静态的
        b.test1();//A类非静态的
    }
}

多态

通过多态可以使代码的可扩展性更强

一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多

多态是方法的多态，属性没有多态

多态存在的条件

• 有继承关系
• 子类重写父类方法
• 父类引用指向子类对象

不能被重写的方法

• static方法属于类，它不属于实例
• final方法属于常量，不能被修改
• private方法不能被重写

public class Person {
    public void run(){
        System.out.println("run");
    }
}

public class Student extends Person {
    @Override
    public void run(){
        System.out.println("son");
    }
    public void Study(){
        System.out.println("Study");
    }
}

public class Application {
    public static void main(String[] args) {
        //一个对象的实际类型是确认的
        //父类的引用指向子类
        Student s1 = new Student();
        Person s2 = new Student();
        Object s3 = new Student();//object是所有类的祖宗类

        //对象能执行那些方法，主要看左边的类型
        s1.run(); //子类能调用的方法都是自己的或者继承父类的
        s2.run(); //子类重写了父类的方法执行子类的方法

        //父类可以指向子类，但是不能调用子类独有的方法。如果要掉用则必须强转
        ((Student) s2).Study();
    }
}

instanceof和类型转换

instanceof主要用来判断两个类是否有关系

子类转父类：向上转型，直接专门丢失子类中原本可以直接调用的特有方法

父类转子类：向下转型，会丢失父类被子类重写的方法

类型转换能方便方法的调用，减少重复的代码，使代码更加简洁

public class Person {
    public void run(){
        System.out.println("run");
    }
}

public class Student extends Person {
    public void go(){
        System.out.println("go");
    }
}

public class Teacher extends Person {

}

public class Appliication {
    public static void main(String[] args) {
        //类型之间的转换：
        Person student1 = new Student();
        ((Student) student1).go();

        System.out.println("==========");
//System.out.println(x instanceof y);
//能不能编译通过主要看xy有没有父子关系

        //Object > Person > Teacher
        //Object > Person > Student
        //Object > String
        Object object = new Student();
        //studnet跟teacher和string无关
        System.out.println(object instanceof Student);//true
        System.out.println(object instanceof Person);// true
        System.out.println(object instanceof Object);// true
        System.out.println(object instanceof Teacher);//false
        System.out.println(object instanceof String);//false
        System.out.println("===============================");

        Person person = new Student();
        System.out.println(person instanceof Student);//true
        System.out.println(person instanceof Person);// true
        System.out.println(person instanceof Object);// true
        System.out.println(person instanceof Teacher);//false
        //System.out.println(person instanceof String);编译报错
        //person和String没有一点关系，他们是同级的

        System.out.println("===============================");
        Student student = new Student();
        System.out.println(student instanceof Student);//true
        System.out.println(student instanceof Person);// true
        System.out.println(student instanceof Object);// true
        //System.out.println(student instanceof Teacher);编译报错
    }
}

static关键字

static用在方法上是静态方法，用在属性上是静态属性

静态变量对于类，所有对象（实例）所共享。可以直接使用类去调用

public class Student {
    private static int age;//静态的属性
    private double score;//非静态的属性
    public void run(){
    }//非静态的方法
    public static void go(){}//静态的方法

    public static void main(String[] args) {
        //非静态方法可以调用静态方法，
        // 静态方法可以调用静态方法但不能调用非静态的方法
        new Student().run();
        go();


        Student s1 = new Student();
        //静态的属性可以通过类直接调用
        System.out.println(Student.age);
        System.out.println(s1.age);
        System.out.println(s1.score);

    }

}

public class Application {
    {
        //代码块（匿名代码块）
        System.out.println("匿名代码块");
    }
    static {
        //静态代码块：跟类一块加载，永久只执行一次
        System.out.println("静态代码块");
    }

    public Application() {
        System.out.println("构造方法");
    }

    public static void main(String[] args) {
        Application application1 = new Application();
        System.out.println("===============");
        Application application2 = new Application();
        /*
        静态代码块
        匿名代码块
        构造方法
        ===============
        匿名代码块
        构造方法
        */
    }
}

抽象类

abstract修饰符可以用来修饰方法也可以修饰类，如果修饰方法，那么该方法就是抽象方法，如果修饰类，那么该类就是抽象类

抽象类中可以没有抽象方法，但是有抽象方法的类一定要声明为抽象类。

抽象类不能使用new关键字来创建对象，它是用来让子类继承的

抽象方法，只有方法的声明，没有方法的实现，它是用来让子类实现的

子类继承抽象类，那么就必须要实现抽象类没有实现的抽象方法，缶则该子类也要声明为抽象类

//抽象类
public abstract class Action {
//抽象方法，只有方法名字，没有方法的实现
    public abstract void run();
    public void go(){
        //抽象类中可以写普通的方法
        System.out.println("go");
    }

    
}

//抽象类的所有方法必须要有子类实现，除非子类也是抽象方法
public class A extends Action{
    //子类必须要重写父类的抽象方法
    @Override
    public void run() {

    }
}

接口

声明类的关键字是class，声明接口的关键字是interface

普通类： 只有具体实现

抽象类： 具体实现和规范（抽象方法）都有

接口： 只有规范

• 接口就是规范，定义的是一组规则
• 接口的本质是契约，就像法律一样。制定好后所有人都要遵守
• 面向对象的精髓，是对对象的抽象，最能体现这一点就是接口。设计模式所研究的，实际上就是如何合理的去抽象
• 接口不能被实例化，接口中没有构造方法

public interface Test {
    void run();
}

//接口也可以继承接口。
// 子类接口被实现后，实现类要重写父类接口和子类接口的所有方法
public interface UserService extends Test{
    //接口中定义的属性都是常量
    int age = 18;
    //接口中不能写方法的实现
    //接口中所有定义的方法都是抽象方法
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}

//接口可以多实现
public class UserServiceImpl implements UserService,Test{
    //类可以实现接口，实现接口的类必须要重写接口的所有方法
    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void query(String name) {

    }

    @Override
    public void run() {

    }
}