面向对象编程

最新推荐文章于 2024-07-10 21:37:49 发布
最新推荐文章于 2024-07-10 21:37:49 发布
阅读量122 收藏
点赞数
分类专栏： java基础学习 文章标签： java 多态 抽象类 面向对象编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45223895/article/details/117166052
版权

面向对象编程

java的核心思想就是OOP（面向对象）

一、初识面向对象

1.1面向过程 & 面向对象

  • 面向过程思想
    1.步骤清晰简单，第一步做什么。第二步做什么
    2.面对过程适合处理一些较为简单的问题
  • 面向对象思想
    1.物以类聚，分类的思维模式，思考问题首先会解决问题需要那些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索
    2.面向对象适合处理复杂的问题，适合处理需要多人协作的问题
  • 对于描述复杂的事物，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是，具体到微观操作，仍然需要面向过程的思路去处理

1.2 什么是面向对象

  • 面向对象编程（Object-Oriented Programming,OOP）
  • 面向对象编程的本质就是：以类的方式组织代码，以对象的方式组织（封装）数据
  • 抽象
  • 三大特性
    1.封装
    2.继承
    3.多态
  • 从认识论角度考虑是先有对象后有类，对象是具体的事物。
  • 从代码运行角度考虑是先有类后有对象。类是对象的模板。

二、方法的回顾和加深

java方法的相关知识

2.1 方法的定义

  • 修饰符
  • 返回类型
  • break和return的区别
  • 方法名
  • 参数列表
  • 异常抛出

2.2 方法的调用

  • 静态方法static
//创建一个包含静态方法的学生类
public class Student{
	public static void say(){
		System.out.println("学生说话了");
	}
}

//main方法中调用
public static void main(String[] args){
	//调用静态方法
	Student.say();
}
  • 非静态方法
//创建一个包含非静态方法的学生类
public class Student{
	public void say(){
		System.out.println("学生说话了");
	}
}

//main方法中调用
public static void main(String[] args){
	//调用非静态方法
	//先new一个对象
	Student student = new Student();
	student.say();
}

static注意事项

  • static是和类一起加载的，非静态方法是需要实例化后才加载的
  • 包含static属性不可调用其他的非静态方法或属性，反之可调用
  • 形参和实参
    形参只是一个占位的，没有具体的值
  • 值传递和引用传递
    1.值传递
//值传递
public class Demo{
	public static void main(String[] args){
		int a = 1;
		System.out.println(a);//1
		Demo.change(a);
		System.out.println(a);//1
	}

	//返回值为空
	public static void change(int a){
		a = 10;
	}
}

2.引用传递

//引用传递：对象，本质还是值传递
public class Demo{
	public static void main(String[] args){
		Person person = new Person();
		System.out.println(person.name);//null
		Demo.change(person);
		System.out.println(person.name);//张三
	}

	public static void change(Person person){
		person.name = "张三";
	}
}

//定义Person类
class Person{
	String name;//null
}
  • this关键字

三、对象的创建分析

3.1 类与对象的关系

  • 类是一种抽象的数据类型，它是对某一类事物整体描述/定义，但是并不能代表某一个具体的事物。
  • 它是用来描述事物应该具备的特点和行为
  • 对象是抽象概念的具体实例
  • 能够体现出特点，展现出功能的是具体的实例，而不是一个抽象的概念
  • 万事万物皆可为对象

3.2 创建与初始化对象

  • 使用new关键字创建对象
  • 使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认初始化以及对类中构造器的调用
//学生类
public class Student{
	//属性
	private String name;
	int age;
	
	//方法
	public void study(){
		System.out.println(this.name+"在学习");
	}
}

//---------------
//main方法中
//类实例化会返回一个自己的对象
Student xiaoming= new Student();
xiaoming.name = "小明";
xiaoming.age = 13;
System.out.println(xiaoming.name);
System.out.println(xiaoming.age);

  • 类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的，并且构造器有以下两个特点：
    1.必须和类的名字相同
    2.必须没有返回类型，也不能写void

  • 构造器必须掌握

public class Student{
	String name;

	//默认的构造方法，默认是隐式的
	//无参构造
	public Person(){

	}

	//重载一个有参构造的方法
	//一旦定义有参构造，必须显式定义无参构造
	public Person(String name){
		this.name = name;
	}
}

//---------------
//main方法中
//new 实例化了一个对象
//通过无参构造创建
Person person1 = new Person();
System.out.println(person1.name);//null
//通过有参构造创建对象
Person person2 = new Person("张三");
System.out.println(person2.name);//张三

构造器总结

  1. 和类名相同
  2. 没有返回值
  • 作用
  1. new本质在调用构造方法
  2. 初始化对象的值
  • 注意
  1. 定义有参构造之后，如果想使用无参构造，需要显式的定义一个无参的构造

3.3 创建对象内存分析

截图

四、面向对象的三大特性

4.1 封装

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

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

  • 属性私有，get/set

public class Student{
	//private 私有
	//属性私有
	private String name;
	private int id;
	private String sex;

	//由于属性私有，外部人员无法操作，因此需要添加get/set方法
	//get获得数据
	public String getName(){
		return this.name;
	}
	//set赋值
	public void setName(String name){
		this.name = name;
	}
}

//-------------main方法
Student s1 = new Student();
s1.setName("张三");
System.out.println("s1.getName()");
  • 封装的意义：
    1.提高程序的安全性，保护数据
    2.隐藏代码的实现细节
    3.统一接口
    4.系统可维护性

4.2 继承

  • 继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。
  • extands的意思是”扩展“，子类是父类的扩展
  • Java中类只有单继承，没有多继承
  • 继承是类和类之间的一种关系，除此之外，类和类之间的关系还有依赖、组合、聚合等
  • 继承关系的两个类，一个为子类（派生类），一个为父类（基类），子类继承父类，使用关键字extends表示
  • 子类和父类之间，从意义上讲应该是具有”is a“的关系
  • object类
  • super(调用父类的属性，前提是不是私有属性，必须要在子类构造器的第一行)
//在Java中：所有的类，都默认继承Object类
//人  父类
public class Person{
	//public:公有属性 默认
	//private:私有属性
	//protected:受保护的
	private int money = 10_0000_0000;

	protected String name = "zhangsan";

	public void say(){
		System.out.println("说了一句话");
	}

	public int getMoney(){
		return money;
	}

	public void setMoney(int money){
		this.money = money;
	}

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

//学生 is 人 ：派生类、子类
//子类继承父类，就会拥有父类的全部方法
public class Student extends Person{
	private String name = "lisi";

	public void test(String name){
		System.out.println(name);//wangwu
		System.out.println(this.name);//lisi
		System.out.println(super.name);//zhangsan
	}

	public void test1(String name){
		print();//Student
		this.print();//Student
		super.print();//Person
	}

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

//老师 is 人 ：派生类、子类
public class Teacher extends Person{
	
}

//main方法
Student student = new Student();
student.say();
System.out.println(student.money);
student.test("wangwu");
student.test1();

总结：
super注意点
1.super调用父类的构造方法，必须在构造方法的第一个
2.super必须只能出现在子类的方法或者构造方法中
3.super和this不能同时调用构造方法
Vs this
1.代表的对象不同
this：本身调用者这个对象；super：代表父类对象的应用
2.前提
this：没有继承也可以使用；super：只能在继承条件下才可使用
3.构造方法区别
this():本类的构造；super():父类的构造

  • 方法重写：重点---->多态，注意区分重写和重载
        重写都是方法的重写，和属性无关
    @Override：重写

重写：需要有继承关系，子类重写父类的方法！
1.方法名必须相同
2.参数列表必须相同
3.修饰符：范围可以扩大 public>protected>default>private
4.抛出异常：范围可以被缩小，但是不能扩大
子类的方法和父类必须一致，方法体不同

  • 为什么需要重写：
        父类的功能子类不一定需要，或者不一定满足！

4.3 多态

  • 即同一方法可以根据发送对象的不同而采用不同的行为方式

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

  • 多态存在的条件
    1.有继承关系
    2.子类重写父类的方法
    3.父类引用指向子类对象

  • 注意：多态是方法的多态，属性没有多态性
    截图

截图

截图

  • instanceof （类型转换）引用类型，判断一个对象是什么类型
    1.Person类
public class Person {

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

2.Student类

public class Student extends Person{

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

3.Teacher类

public class Teacher extends Person{

}

4.main方法

public class Application {
    public static void main(String[] args) {
        //Object > Person > Teacher
        //Object > Person > 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);//编译报错

        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);//编译报错
//        System.out.println(person instanceof String);//编译报错

        //类型之间转换：父    子
        Person obj = new Student();
//        student1.go(); 将obj转化为Student类型
        //强转
        ((Student)obj).go();
    }
}

总结
1.非静态方法new对象时，真正的类型看等号右边；静态属性看等号左边
2.父类引用指向子类的对象
3.把子类转换为父类, 向上转型 : 自动转换 (父类引用无法使用 指向的子类对象的独有方法, 丢失)
4.把父类转换为子类, 向下转型 : 强制转换
5.方便方法的调用，减少重复代码，是代码更简洁

4.4 static关键字详解

//static
public class Student {


    private static int age;//静态变量
    private double score;//普通变量

    //2：赋初值
    {
        //代码块（匿名代码块）
        System.out.println("匿名代码块");
    }

    //1:只执行一次
    static {
        //静态代码块
        System.out.println("静态代码块");
    }

    //3
    public Student(){
        System.out.println("构造方法");
    }

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

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

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

        System.out.println(Student.age);
        System.out.println(s1.age);
        System.out.println(s1.score);

        Student.go();
        go();
//        run();

        s1.go();
        s1.run();
    }
}

截图
static 是优先存在于类的，同时只会被执行一次

  • 拓展使用
//静态导入包后，可以以方式2格式写
//若不以这种方式导入包，则只能按照方式1使用；
import static java.lang.Math.random;

public class Test {

    public static void main(String[] args) {
        System.out.println(Math.random());//1
        System.out.println(random());//2
    }
}

注意：被final关键字修饰后，断子绝孙！！！

五、抽象类和接口

5.1 抽象类

  • abstract修饰符可以用来修饰方法也可以修饰类，那么该方法就是抽象方法；如果修饰类，那么该类就是抽象类
  • 抽象类中可以没有抽象方法，但是抽象方法的类一定要声明为抽象类
  • 抽象类，不能使用new关键字来创建对象，它是用来子类继承的
  • 抽象方法，只有方法的声明，没有方法的实现，它是用来让子类实现的
  • 子类继承抽象类，那么就必须要实现抽象类没有实现的抽象方法，否则该子类也要声明为抽象类
//抽象类
public abstract class Action {

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

//抽象类的所有方法，继承了它的子类，都必须要实现它的方法，除非它也是一个抽象类
public class A extends Action{

    @Override
    public void doSomething() {

    }
}

  • 特点：
    1.不能new这个抽象类，只能靠子类去实现它
    2.抽象类中可以写普通方法
    3.抽象方法必须在抽象类中

  • 类只能单继承

5.2 接口（interface）

  • 普通类：只有具体实现
  • 抽象类：具体实现和规范（抽象方法）都有
  • 接口：只有规范！
  • 接口就是规范，定义的是一组原则，体现了现实世界中“如果你是…则必须能…”的思想。如果你是天使，则必须能飞
  • 接口的本质就是契约，就像我们人间的法律一样，制定好后大家都遵守
  • OOP的精髓，是对 对象的抽象，最能体现这一点就是接口
  • 接口可以多继承
  • 接口不能实例化，接口没有构造方法
//接口需要实现类
public interface UserService {

    //属性默认常量 public static final
    int age = 100;

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

public interface TimeService {

    public void timer();
}

//抽象类：extends 单继承
//接口的实现类: implements 多继承
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) {

    }

    @Override
    public void timer() {

    }
}

六、内部类（拓展）

  • 内部类就是一个类的内部在定义一个类，比如A类中定义一个B类，那么B类相对A类来说就称为内部类，而A类相对于B类来说就是外部类了。
  1. 成员内部类
public class Outer {

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

    //内部类
    public class Inner{

        public void in(){
            System.out.println("外部类方法");
        }

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

//------------------main方法中
		Outer outer = new Outer();
        //通过外部类实例化内部类
        Outer.Inner inner = outer.new Inner();
        inner.in();
        inner.getId();
  1. 静态内部类
public class Outer {

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

    //内部类
    public static class Inner{

        public void in(){
            System.out.println("外部类方法");
        }

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


//--------------------main方法
public static void main(String[] args) {
        Outer outer = new Outer();
        //无法通过外部类实例化内部类
//        Outer.Inner inner = outer.new Inner();
//        inner.in();
//        inner.getId();
    }
  1. 局部内部类
public class Outer {

    public void method(){

        class Inner{
            public void in(){
                
            }
        }
    }

}

//一个java类中可以有多个class类，但是只能有一个public class
class A{

}
  1. 匿名内部类
public class Test {

    public static void main(String[] args) {
        Apple apple = new Apple();
        //没有名字初始化类,不用将实例保存在变量中
        new Apple().eat();
    }
}


class Apple{
    public void eat(){
        System.out.println("1");
    }
}
不吃香菜的小王
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C++面向对象程序设计课程大作业-通讯录管理系统
05-21
本项目是基于C++的面向对象程序设计实现，旨在教授学生如何运用面向对象编程思想来构建实际的应用程序。** **一、面向对象编程基础** 面向对象编程（Object-Oriented Programming，OOP）是一种编程范式，其核心思想...
Labview面向对象编程
10-31
Labview面向对象编程是NI...通过学习和掌握Labview面向对象编程，开发者可以构建出更复杂、更易于维护的应用程序，适应不断变化的需求，并利用Labview的强大功能进行数据分析、控制工程、测试测量等领域的项目开发。
java面向对象编程pdf
04-16
面向对象编程（Object-Oriented Programming，OOP）是一种编程范式，它将程序设计看作是对象的交互，对象之间的关系和行为。 一、对象和类 在Java中，对象是指具有某些特征和行为的实体，例如人、学生、大象、冰箱...
Labview面向对象编程快速入门.pdf
05-11
Labview面向对象编程快速入门
Java面向对象程序设计+源代码+课后习题答案)
10-31
Java面向对象程序设计是计算机科学中的一个重要领域，它基于面向对象编程（OOP）的概念，是一种强大的编程范式。在Java中，OOP的核心概念包括类、对象、封装、继承、多态等。这本书"Java面向对象程序设计"由耿祥义和...
配置Java开发环境
最新发布
Broken_x的博客
07-10 936
Java开发环境配置
关于static定义初始化块和静态变量以及初始化块的执行顺序问题
你我约定有三的博客
07-08 264
第二步：在类加载的时候，按照从上到下执行static修饰的代码，此时执行static Test2 test1 = new Test2()，也就是创建出一个名为test1的对象。第六步：此时除了main方法，所有由static修饰的代码全部执行完毕(static修饰的代码只执行一次)，类初始化完成，开始执行main方法，main方法中只有一条语句(中的代码,此时输出aa以及a的值(由于第一步没赋初值，并且给了默认值为0 所以输出0)//首先输出a的值为10 然后输出bb，最后将a的值定义为11。
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
小明的Java问道之路
07-08 1724
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
java Object 转 Integer
servepeople的博客
07-09 1171
在 Java 中，可以通过多种方法将一个Object转换为Integer。
java占位符替换五种方式
weixin_61478518的博客
07-08 342
在业务开发中，经常需要输出文本串。其中，部分场景下大部分文本内容是一样的，只有少部分点是不一样。简单做法是直接拼接字段，但是这会有个问题。后面如果想要修改内容，那么每个地方都要修改，这不符合设计模式中的开闭原则，面向应该对扩展开放，对修改关闭。如何解决这个问题？先来看现实生活中的例子，个人信息填写。一般会要填写表格，已经定义好了姓名，性别，年龄等字段，只要填写对应的个人信息就好了。在程序开发中，我们会预先定义好一个字符串模板，需要改动的点使用占位符。
AI技术的转变：从辨别式到生成式
学IT，找陈寒
07-09 2847
李彦宏在2024世界人工智能大会上的发言，提醒我们在AI技术发展的道路上，不要盲目追求技术本身或表面的用户数据，而应更多地关注技术的实际应用和产业价值。在大模型技术与个性化应用之间找到平衡，将是未来发展的关键。作为AI从业者和技术爱好者，我们应以务实的态度，探索AI技术在各个领域的实际应用，为产业发展和社会进步贡献力量。通过李彦宏的发言，我深刻认识到AI技术发展的方向和挑战，也更加坚定了自己在这一领域继续探索和创新的信心。未来，愿我们共同努力，推动AI技术更好地服务于社会和产业，为人类创造更美好的未来。
java中 使用数组实现需求小案例（二）
qq_44304677的博客
07-09 779
java小案例，数组需求实现，使用Random函数实现用户输入随机数生成一个打乱的数组
JavaSE 面向对象程序设计进阶 IO流 字节流详解 抛出异常
牛马程序员的博客
07-10 602
存储和读取数据的解决方案内存中数据不能永久化存储 程序停止运行 数据消失File只能对文件本身进行操作 不能读写文件里存储的数据读写数据必须要有IO流可以把程序中的数据保存到文件当中还可以把本地文件中的数据读取到数据当中。
图片压缩代码和实际操作页面
英雄汉孑的博客
07-05 1047
轻盈视界，高清依旧 —— 智能图片压缩，大容量，小体积，精彩不打折
基于SpringBoot的招聘信息管理系统的详细设计和实现(源码+lw+部署文档+讲解等，欢迎咨询我！！)
程序员阿龙的博客
07-06 1367
本次分享的是一个基于java开发的招聘信息管理系统，也说明了自己的开发实力，欢迎各位小伙伴来咨询相关业务，也可以参考一下这个文章！！
返回值处理器器【Spring源码学习】
weixin_44794897的博客
07-05 329
定义返回值类型处理器的组合；测试使用的controller测试方法。
学习mybatis
weixin_45621552的博客
07-08 659
【代码】学习mybatis。
基于springboot的工作绩效管理系统的设计与实现+文档
欧阳小白闯天涯
07-05 730
本毕业设计旨在设计与实现基于Spring Boot的工作绩效管理系统，以满足现代企业对绩效管理的需求。随着企业规模的不断扩大和竞争日益激烈，高效的绩效管理成为提升企业竞争力的重要手段。本系统将利用Spring Boot框架搭建，结合MySQL数据库和MyBatis持久层框架，以及Thymeleaf模板引擎，为企业提供全面的绩效管理解决方案。系统功能包括员工和管理员两个角色。员工可通过系统进行绩效管理、工资管理、统计分析、请假管理以及公告管理等操作，从而提升工作效率和满足个人需求。
学java的第3天 后端商城小程序工作
weixin_67865831的博客
07-05 865
我的图片表中有一个字段是描述我写成desc了，正好是mysql中的关键字 就不能使用了。
c++面向对象程序设计完整ppt课件.ppt
11-16
c++面向对象程序设计完整ppt课件.ppt

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

不吃香菜的小王

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值