05-Java面向对象

已于 2022-09-20 20:36:31 修改
阅读量364 收藏
点赞数 2
分类专栏： Java学习笔记 文章标签： java jvm 开发语言
于 2022-09-18 21:32:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/purvispanwu/article/details/126911232
版权

文章目录

初识面向对象

面向过程&面向对象

在这里插入图片描述

回顾方法及加深

在这里插入图片描述

  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 + "在学习");
    }
}

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);

    }
}

构造器详解

在这里插入图片描述

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

在这里插入图片描述

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

public class Person {
    //一个类即使什么都不写，他也会存在一个方法
    
    //显示的定义构造器
    public Person(){
        
    }
    
}
  • 实例化构造器初始值
    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方法
}

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());

    }
}

继承

在这里插入图片描述

  • 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("说了一句话");
    }

}
  • 子类Student
package oop;

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

}
  • 子类Teacher
package oop;

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

}
  • 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);
    }
}
Super

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

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

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

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

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

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

在这里插入图片描述

  • 隐藏代码，子类的无参构造会先调用父类的无参构造
    在这里插入图片描述
  • 调用父类的构造器，必须在子类构造器的第一行
    在这里插入图片描述
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);//编译就报错
    }
}
类型转换示例
  • Person类-父类
package oop;


public class Person {

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

}
  • Student类-子类
package oop;

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

}
  • 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;
    }
}
  • 子类转换为父类，可能会丢失自己本来的一些方法
    在这里插入图片描述

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()方法为非静态方法，要实例化后才会存在

    }

}
  • 静态导入包
    -在这里插入图片描述

抽象类和接口

抽象类

在这里插入图片描述

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

//抽象类 abstract
public abstract class Action {

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

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

}

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

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

    }
}

接口

作用：
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);
}
  • TimeService接口
package oop;

public interface TimeService {
}
  • 接口的实现类-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) {

    }
}

内部类及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{
        }
    }
    
}
  • 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();
    }


}
Purvis_U
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
7-2 jmu-Java-03面向对象基础-05-覆盖 (15分)
sddfnsff的博客
06-15 6990
Java每个对象都继承自Object,都有equals、toString等方法。 现在需要定义PersonOverride类并覆盖其toString与equals方法。 新建PersonOverride类 a. 属性：String name、int age、boolean gender，所有的变量必须为私有(private)。 b. 有参构造函数，参数为name, age, gender c. 无参构造函数，使用this(name, age,gender)调用有参构造函数。参数值分别为"default"
jmu-Java-03面向对象基础-05-覆盖
黑白的黒's Blog
10-01 4427
Java每个对象都继承自Object,都有equals、toString等方法。 现在需要定义PersonOverride类并覆盖其toString与equals方法。 1. 新建PersonOverride类 a. 属性：String name、int age、boolean gender，所有的变量必须为私有(private)。 b. 有参构造函数，参数为name, age, gender c. 无参构造函数，使用this(name, age,gender)调用有参构造函数。参数值分别为"default
7-5 jmu-Java-03面向对象基础-05-覆盖 (3分)
ccyynmb的博客
04-15 2857
getConstructors()方法作用：获得类中全部构造方法的执行顺序。 注意点：无参构造和有参构造写入顺序不同输出顺序也不同。 使用方法：类名.class.getConstructors()是完整的方法书写格式。 报错：cannot be referenced from a static context 正确输出格式： [public PersonOverride(), public...
02-JAVA面向对象-达内
最新发布
10-27
02_JAVA面向对象_达内
第5章-JAVA面向对象编程基础.ppt
11-21
JAVA面向对象编程基础 JAVA面向对象编程是面向对象编程语言的基础，包含定义类、创建类的实例对象、构造函数、访问控制修饰符、静态属性和静态方法等内容。 一、定义类 在JAVA中，定义类使用class关键字，语法...
Java-03面向对象-06-继承覆盖综合练习-Person、Student、Employee、Company
12-28
pta题目java的继承覆盖综合题源码，全部内容为自己原创，能够运行但是有些代码可能写的不是很精简，这个摘要也太长了吧，凑不够字数啊
习题解答-Java面向对象程序设计-邢国波-清华大学出版社.pdf
07-06
Java面向对象程序设计是计算机科学中的一个重要主题，尤其在Java编程中。邢国波的《Java面向对象程序设计》一书旨在帮助读者理解和掌握Java语言的核心特性，特别是面向对象编程的概念。以下是根据提供的内容和标签...
Java-面向对象设计-类和对象.docx
12-16
Java面向对象设计类和对象 Java面向对象设计类和对象是面向对象程序设计的基础，它将现实世界模型自然延伸到程序设计中。类和对象是面向对象设计的核心概念，类描述对象的属性和行为，对象是类的实例，是一个实实在...
PTA jmu-Java-03面向对象基础-05-覆盖分数 10
weixin_70206677的博客
03-04 797
jmu-Java-03面向对象基础-05-覆盖 分数 10
面向对象03-java基础
ytt199599的博客
02-22 312
一、对象转型 1、基类的引用变量可以指向其子类的对象； 2、一个基类的引用不可以访问子类新添加的对象和方法； 3、可以使用“引用变量 instanceof 类名”来判断该引用型变量所指向的对象是否属于该类或该类的子类； 4、子类的对象可以看做是基类的对象，称做：“向上转型”，反之，称为向下转型。 Eg:参考代码如下： 先定义父类Animal; public class Animal
java 遍历无参方法_【Java】方法的定义、有参|无参构造函数、带返回值定义、重载、参数传递、数组的遍历...
weixin_34769715的博客
02-16 191
1. 方法概述1.1 方法的概念(理解)方法(method)是将具有独立功能的代码块组织成为一个整体，使其具有特殊功能的代码集注意：方法必须先创建才可以使用，该过程成为方法定义方法创建后并不是直接可以运行的，需要手动使用后，才执行，该过程成为方法调用2. 方法的定义和调用2.1 无参数方法定义和调用(掌握)定义格式：public static void 方法名 ( ) {// 方法体;}范例：...
PTA7-1 jmu-Java-03面向对象基础-05-覆盖 (3 分)
weixin_53361781的博客
05-08 1708
7-1 jmu-Java-03面向对象基础-05-覆盖 (3 分) 7-1 jmu-Java-03面向对象基础-05-覆盖 (3 分) Java每个对象都继承自Object,都有equals、toString等方法。 现在需要定义PersonOverride类并覆盖其toString与equals方法。 ###1. 新建PersonOverride类 a. 属性：String name、int age、boolean gender，所有的变量必须为私有(private)。 b. 有参构造函数，参数为name
7-5 jmu-Java-03面向对象基础-05-覆盖 (20 分)
千色千寻的博客
08-11 1068
7-5 jmu-Java-03面向对象基础-05-覆盖 (20 分) Java每个对象都继承自Object,都有equals、toString等方法。 现在需要定义PersonOverride类并覆盖其toString与equals方法。 1. 新建PersonOverride类 a. 属性：String name、int age、boolean gender，所有的变量必须为私有(private)。 b. 有参构造函数，参数为name, age, gender c. 无参构造函数，使用this(name,
4-4 jmu-java-m04-Abstract、Person、Student、Teacher (10分)
munaiyi13的博客
05-01 2256
该程序包含 Person类(抽象类)： 属性：int id, String name, LocalDate birthDate。注意：定义时需按照顺序从上到下定义。 方法：构造方法（id, name, year, month, dayOfMonth）; id与birthDate的getter方法; name的getter/setter方法;Eclipse自动生成的tostring;抽象方法Stri...
7-5 jmu-Java-03面向对象基础-05-覆盖 (3 分)
世界在我口袋的博客
03-11 4782
Java每个对象都继承自Object,都有equals、toString等方法。 现在需要定义PersonOverride类并覆盖其toString与equals方法。 ###1. 新建PersonOverride类 a. 属性：String name、int age、boolean gender，所有的变量必须为私有(private)。 b. 有参构造函数，参数为name, age, gender c. 无参构造函数，使用this(name, age,gender)调用有参构造函数。参数值分别为"defa
java 常用工具类
qq_31459039的博客
03-14 4565
Apache Commons包估计是Java中使用最广发的工具包了，很多框架都依赖于这组工具包中的一部分，它提供了我们常用的一些编程需要，但是JDK没能提供的机能，最大化的减少重复代码的编写。 org.apache.commons.lang3 为加强版的 org.apache.commons.lang 功能更加丰富 一. org.apache.commons.lang3.StringUtil.....................
Cobalt Strike4.0安装以及java/jdk环境安装百分百成功
告白的博客
08-05 4157
0x00 Cobalt Strike介绍 是一款使用java编写，C / S架构的商业渗透软件，适合多人进行团队协作，可模拟APT做模拟对抗，进行内网渗透，是一个为对手模拟和红队行动而设计的平台，主要用于执行有目标的攻击和模拟高级威胁者的后渗透行动，行业内称之为后渗透神器,客户端不与服务端做交互，服务端可以与客户端做交互 作用： 自定义驱动，收集社会工程学资料进行摩斯密码类型（电话攻击）攻击 收集网络环境获得基本资料 进行跨平台攻击 降低后渗透攻击难度，进行内网横向扩展 端口转发、扫描多模式端口Lis
jmu-java-03面向对象基础-05-覆盖
06-28
覆盖，又称重写或重载，是面向对象编程中的一种重要概念。它指子类对父类中已有的方法进行重新定义，使得子类中的方法能够覆盖父类中的方法，从而实现多态性。 要使用覆盖，需要遵循如下规则： - 方法名、参数列表...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值