• 05-Java面向对象

    文章目录

    初识面向对象

    面向过程&面向对象

    在这里插入图片描述

    回顾方法及加深

    在这里插入图片描述

    1. static方法是和类一起加载的，下面没有加static的方法需要实例化之后才存在
      在这里插入图片描述
    2. 值传递 在这里插入图片描述
    3. 引用传递
      在这里插入图片描述

    Java方法详解

    对象的创建分析

    创建与初始化对象

    在这里插入图片描述

    • 一个项目应该只存在一个main方法
      Student类
    package oop;

//学生类
public class Student {
    //属性：字段
    String name;
    int age;

    //方法
    public void study() {
        System.out.println(this.name + "在学习");
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    Application类-main方法
    调用Student类

    package oop;

//一个项目应该只存在一个main方法
public class Application {
    public static void main(String[] args) {
        //类：抽象的，实例化
        //类实例化后会返回一个自己的对象
        //student对象就是一个Student类的具体实例
        Student student = new Student();
        Student xiaoming = new Student();
        Student xh = new Student();

        xiaoming.name = "小明";
        xiaoming.age = 3;
        System.out.println(xiaoming.name);
        System.out.println(xiaoming.age);

    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20

    构造器详解

    在这里插入图片描述

    构造器-无参（默认）
    • Person类啥方法都没有都能被实例化出来（一个类即使什么都没写，它也会存在一个方法即构造器）

    在这里插入图片描述

    • 构造器必须和类的名字相同
    • 必须没有返回值类型
    package oop;

public class Person {
    //一个类即使什么都不写，他也会存在一个方法
    
    //显示的定义构造器
    public Person(){
        
    }
    
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 实例化构造器初始值
      Alt+insert 快捷方式创建构造器
      在这里插入图片描述
    构造器-有参
    • 一旦定义了有参构造，无参就必须显示定义
      在这里插入图片描述

    创建对象内存分析(简易)

    在这里插入图片描述

    在这里插入图片描述

    面向对象的三大特征

    封装

    在这里插入图片描述

    封装的作用
    1. 提高程序的安全性，保护数据
    2. 隐藏代码的实现细节
    3. 统一接口
    4. 系统可维护性增加了
    封装演示
    • 示例代码
      Student类
    package oop;

//学生类
public class Student {
    private String name; //private属性私有，外部对象new了这个对象没法去用这个属性
    private int id;
    private char sex;
    private int age;
    //提供一些可以操作这个属性的方法
    //提供一些public的 get、set方法

    //get获得这个数据
    public String getName() {
        return name;
    }

    //set给这个数据设置值
    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        if (age > 120 || age < 0) {
            System.out.println("输入的年龄不合法");
        } else {
            this.age = age;

        }
    }

    //alt+insert 自动生成get set方法
}



    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34

    Application类-main方法

    package oop;

//一个项目应该只存在一个main方法
public class Application {
    public static void main(String[] args) {
        Student s1=new Student();
        s1.setName("purvis");
        System.out.println(s1.getName());

    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    继承

    在这里插入图片描述

    • Ctrl+h 查看继承树
      在这里插入图片描述
    • Java中，所有的类，都默认继承Object类
      在这里插入图片描述
    继承示例
    • 父类-Person
    package oop;

//Person类：父类
public class Person {
    //public
    //protected
    //default
    //private
    public int money = 10_0000_0000;
    public void say(){
        System.out.println("说了一句话");
    }

}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 子类Student
    package oop;

//Student类继承Person类：子类
    //子类继承了父类就会拥有父类的全部方法
public class Student extends Person {

}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 子类Teacher
    package oop;

//Teacher类继承Person类：子类
public class Teacher extends Person{

}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • Application-main方法
    package oop;

//一个项目应该只存在一个main方法
public class Application {
    public static void main(String[] args) {
        Student student=new Student();
        student.say();
        int m = student.money;
        System.out.println("继承父类的money:"+m);
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    Super

    1. 当子类与父类有同名的属性时，可以通过super.属性的方式调用父类中的属性。

    2. 当子类重写父类的方法后，在子类中若想调用父类中被重写的方法时，需用super.的方法

    3. super修饰构造器，通过在子类中使用super列表参数的形式调用父类中制定的构造器

       a、在构造器内部，super（参数列表）必须声明在首行

 b、在构造器内部，this（参数列表）或super（参数列表）只能出现一个

 c、当构造器中不显示的调用this（参数列表）或super（参数列表）默认调用父类中的空参构造器

      • 1
      • 2
      • 3
      • 4
      • 5

    在这里插入图片描述

    • 隐藏代码，子类的无参构造会先调用父类的无参构造
      在这里插入图片描述
    • 调用父类的构造器，必须在子类构造器的第一行
      在这里插入图片描述
    Super注意点
    1. super调用父类的构造方法，必须在构造方法的第一个
    2. super必须只能出现在子类的放法或构造方法中
    3. super和this不能同时调用构造方法
    super VS this

    • 代表的对象不同：
      this：本身调用者这个对象
      super:代表父类对象的引用

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

    • 构造方法
      this();本类的构造
      super();父类的构造

    方法重写
    • 重写都是方法的重写（子类重写父类的方法）
    • 参数列表必须相同
    • 重写跟静态方法无关，只跟非静态方法有关
    • 修饰符：范围可以扩大但不能缩小：public>protected>default>private
    • 抛出的异常：范围可以缩小。但不能扩大

    在这里插入图片描述

    • 父类的引用指向了子类（静态方法）
      在这里插入图片描述

    • 方法重写示例
      重写的关键词必须是public不能是private
      在这里插入图片描述

    • 静态方法和非静态区别很大

      1. 静态方法：方法的调用只和左边定义的对象有关（上上图）
      2. 非静态方法：可以重写

    多态

    在这里插入图片描述
    在这里插入图片描述

    多态注意事项

    在这里插入图片描述

    类型转换- instanceof
    package oop;

//一个项目应该只存在一个main方法
public class Application {
    public static void main(String[] args) {
        //Object->String
        //Object->Person->Teacher
        //Object->Person->Student
        //Object为Student的爸爸的爸爸类
        Object object = new Student();
        //System.out.println(X instanceof Y);//能不能编译通过！

        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);//编译就报错
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    类型转换示例
    • Person类-父类
    package oop;


public class Person {

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

}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • Student类-子类
    package oop;

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

}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • Application主类-main方法
    package oop;

//一个项目应该只存在一个main方法
public class Application {
    public static void main(String[] args) {
        //类型之间的转换；基本类型转换 高转低 强转

        //高               //低
        Person obj = new Student();
        obj.go(); //会报错,因为Person类没有go方法

        //obj 将这个对象转换成Student类型，我们就可以使用Student类型的方法了！（高转低）
        Student student = (Student) obj;  //强制转换成Student类型 或者 ((Student)obj).go;
    }
}



    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 子类转换为父类，可能会丢失自己本来的一些方法
      在这里插入图片描述

    static关键字详解

    package oop;

public class Student {
    private static int age; //静态的变量，在类中会被共享，可以直接类名.属性调用
    private double score;//非静态的变量

    public void run() {

    }

    public static void go() {

    }

    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);
        System.out.println("=========================");
        Student.go();//可以直接调
        go(); //可以直接调
        Student.run();//没法直接调用,原因是静态的方法static会跟类一起加载，run()方法为非静态方法，要实例化后才会存在

    }

}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 静态导入包
      -在这里插入图片描述

    抽象类和接口

    抽象类

    在这里插入图片描述

    • 演示
      Action类-抽象类
    package oop;

//抽象类 abstract
public abstract class Action {

    //约束~有人帮我们实现~
    //abstract ,抽象的方法，只有方法名字，没有方法的实现！
    public abstract void doSomething();

    // 1.不能new抽象类，只能靠子类去实现它：约束！
    // 2.抽象类中可以写普通的方法~
    // 3.抽象方法必须在抽象类中

}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15

    A类-继承抽象类（要重写父类的方法才行）

    package oop;
//抽象类的所有方法，继承了它的子类，都必须要实现它的方法~ 除非~
public class A extends Action {
    @Override
    public void doSomething() {

    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    接口

    作用：
    1.约束
    2.定义一些方法，让不同的人实现
    3.接口不能被实例化~接口中没有构造方法
    4.implements可以实现多接口
    5.必须要重写接口中的方法
    在这里插入图片描述

    • UserService接口
    package oop;

//interface 定义的关键字
//接口都需要实现类
public interface UserService {
    //变量一般都是常量
    public static final int AGE = 99;

    //接口中的所有定义其实都是抽象的 public abstract
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • TimeService接口
    package oop;

public interface TimeService {
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 接口的实现类-UserServiceImpl
    package oop;

//接口的实现类
//类 可以实现接口  implements接口
//实现了接口的类，就需要重写接口的方法
//利用接口实现多继承，如下 继承 UserService,TimeService 两接口
public class UserServiceImpl implements UserService,TimeService {
    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void query(String name) {

    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28

    内部类及OOP实战

    内部类

    在这里插入图片描述

    • Outer类
    package oop;

//Outer为外部类
public class Outer {

    private int id;
    public void out(){
        System.out.println("这是外部类的方法");
    }

        //Inner为内部类
    class Inner{
        public void in(){
            System.out.println("这是内部类的方法");

        }

        //获得外部类的私有属性~
        public void getId(){
            System.out.println(id);
        }
    }


    public void method(){
        //局部内部类
        class Ineer{
        }
    }
    
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • Application类-main
    package oop;

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

        //new
        Outer outer = new Outer();

        //通过这个外部类来实例化内部类~
        Outer.Inner inner = outer.new Inner();
        inner.in();
        inner.getId();
    }


}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
  • 相关阅读:
    Spring使用的注解大全和解释
    windows Visual Studio 2022 opengl开发环境配置
    [apue] 进程环境那些事儿
    访谈：联合开发网站长，罚款50万之后的问答与建议
    数据库测试技术点
    集群规模：3 FE + 89 BE
    基于单片机的洗衣机仿真设计(#0022)
    SLAM中去除动态物体的部分方法（主要是视觉SLAM）
    不愧是阿里架构师，吐血更新笔记，这应该是对“Spring家族”最完美的诠释了！
    拾壹博客拆解改造，页面元素替换（二）
  • 原文地址：https://blog.csdn.net/purvispanwu/article/details/126911232