Day09 面向对象编程（oop）

最新推荐文章于 2024-05-25 10:57:37 发布
最新推荐文章于 2024-05-25 10:57:37 发布
阅读量81 收藏
点赞数
分类专栏： Java基础 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_49235405/article/details/125195490
版权

1、面向对象（oo）

  • 面向对象&面向过程

    • 面向过程思想：

      • 步骤清晰简单，第一步、第二步做什么...

      • 面向过程适合处理一些较为简单的问题。

    • 面向对象思想：

      • 物以类聚，分类的思维模式，思考问题首先先解决问题需要那些分类，然后对这些进行单独思考。最后，才对某个分类下的细节进行面向过程的思索。

      • 面向对象适合处理复杂的问题，适合处理需要多人协作的问题！

    • 对于描述复杂的事务，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是，具体到微观操作，仍然需要面向过程的思路去处理。

  • 什么事面向对象

    • 面向对象编程（OOP）

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

    • 核心思想：抽象

    • 三大特性：

      • 封装

      • 继承

      • 多态

    • 对象是具体的，类是抽象的，是对对象的抽象

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

  • 类与对象的关系

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

      • 动物、植物、手机...

      • Person类、Pet类、Car类等，这是类都是用来描述/定义某一类具体的事务应该具备特点和行为。

    • 对象时抽象概念的具体实例

      • 张三就是人的一个具体实例，张三家里的旺财就是狗的一个具体实例。

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

2、方法回顾和加深

  • 方法的定义

    • 修饰符：static

    • 返回类型

    • break 结束循环，return 返回

    • 方法名：注意规范，见名知意

    • 参数列表：（参数类型 参数名） 可变参数...

    • 异常抛出：目前知道数组下标越界异常

  • 方法的调用：

    • 静态方法：有static修饰

    • 非静态方法：没有static修饰

    • 形参和实参

    • 值传递和引用传递

    • this关键字

值传递和引用传递

/**
 * @author: ZJG
 * @date: 2022/6/5 22:35
 * @description: 值传递
 */
public class Demo01 {
​
    public static void main(String[] args) {
        int a = 1;
​
        System.out.println(a); // 1
        //实参 值传递
        test(a);
​
        System.out.println(a);//1
​
    }
​
    //公开 静态 返回类型 方法名 形参
    public static void test(int a){
         a = 10;
    }
​
}
/**
 * @author: ZJG
 * @date: 2022/6/5 22:39
 * @description: 引用传递本质还是值传递
 */
public class Demo02 {
​
    public static void main(String[] args) {
        Student student = new Student();
        System.out.println(student.name);//null
​
        test(student);
​
        System.out.println(student.name);//王者
    }
​
    public static void test(Student student){
        student.name = "王者";
    }
}
//一个类只能有一个public class修饰的类，但是可以有多个 class修饰的类，类名不重复。
class Student{
    //属性
    String name;
}

静态方法和非静态方法

/**
 * @author: ZJG
 * @date: 2022/6/5 22:46
 * @description:  静态方法和非静态方法
 */
public class Demo03 {
​
    public static void main(String[] args) {
​
        //调用静态方法
        test1();
        //调用非静态方法
        //方式一
        new Demo03().test2();
        //方式二
        Demo03 demo03 = new Demo03();
        demo03.test2();
        
    }
​
​
    //静态方法
    public static void test1(){
        return;
    }
​
    //非静态方法
    public void test2(){
        return;
    }
​
}
​

3、对象的创建分析

  • 创建与初始化对象

    • 使用new关键字创建对象

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

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

      • 1 必须和类的名字相同

      • 2 必须没有返回类型，也不能写void

    • 构造器必须要掌握。

public class Person {
    //属性
    String name;
    int age;
​
​
    //方法
    public void study(){
        System.out.println("名字："+this.name);
    }
}

使用new关键字创建对象、给创建好的对象默认初始化值

public class Demo04 {
​
    public static void main(String[] args) {
        /*
            类：抽象的，实例化
            类实例化后会发返回一个自己的对象。
            person1对象就是一个Person类的具体实例。
         */
        Person person1 = new Person();
​
        //默认值
        System.out.println(person1.name);//null
        System.out.println(person1.age);//1
​
        //赋值
        person1.name = "张三";
        person1.age = 18;
        System.out.println(person1.name);//张三
        System.out.println(person1.age);//18
        
        //调用方法
        person1.study();
​
    }
​
}

构造器

public class Person {
    //一个类即使什么都不写，它也会存在一个方法。构造器
    String name;
    int age;
​
​
    /*
           构造器：
            1、和类名相同
            2、没有返回值
           作用：
            1、new 本质在调用构造方法
            2、初始化对象的值
           注意：
            1、定义有参构造之后，如果想使用无参构造，显示的定义一个无参1构造
     */
​
​
    //无惨构造
    //实例化初始值
    //1、使用new关键字，本质是调用构造器
//    public Person(){
//        this.name = "ZJG";
//    }
    public Person(){}
​
    //有参构造
    //一旦定义了有参构造，无参构造必须显示定义。
    public Person(String name){
        this.name = name;
    }
​
    //有参构造
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}
public class Demo05 {
​
    public static void main(String[] args) {
        //new 实例化对象
        //可以选择 无惨构造赋值&有参构造赋值 方式
        Person person = new Person("ZJG");
​
        System.out.println(person.name);//ZJG
​
    }
}

内存分析

public class Pet {
    //属性
    public String name;
    public int age;
​
​
    //无参构造默认存在
​
    //方法
    public void test(){
        System.out.println("叫了一声");
    }
​
}
public class Application {
    public static void main(String[] args) {
        Pet pet = new Pet();
        pet.name = "旺财";
        pet.age = 3;
        pet.test();

        System.out.println(pet.name);
        System.out.println(pet.age);
    }
}

 

4、面向对象三大特性

封装

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

  • 封装（数据的隐藏）

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

  • 封装只记住：属性私有, get/set

public class Pet {

    //属性私有，提供安全性
    private String name;
    private int age;

    //提高些可操作属性的方法，设置和获取数据

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        //年龄不合法，封装方法做判断，如果超出给设置默认年龄
        if (age > 120 || age < 0){
            this.age = 3;
        }else {
            this.age = age;
        }

    }
}

public class Application {

    public static void main(String[] args) {

        /*
            1、提供程序安全性
            2、隐藏代码细节
            3、统一接口
            4、系统可维护性提高。
         */

        Pet pet = new Pet();
        pet.setName("张三");
        //年龄不合法，封装方法做判断，如果超出给设置默认年龄
        pet.setAge(999);

        String name = pet.getName();
        int age = pet.getAge();

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

}

继承

  • extends 的意思是 “拓展”，子类是父类的拓展。

  • java中只有单继承，没有多继承。（可理解为1个儿子只有1个巴巴，而1个巴巴可以有多个儿子）

  • 继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等。

  • 继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends表示。

  • Object类 - 所有类直接或间接都继承它。

/**
 * @author: ZJG 
 * @date: 2022/6/7 22:15
 * @description: 学生 子类继承父类，就会拥有父类的全部方法！
 */
public class Student extends Person{
}


/**
 * @author: ZJG
 * @date: 2022/6/7 22:15
 * @description: 人
 */
public class Person {

    //私有 - 父类私有-但是设置了方法方法可以调用和修改
    private String name = "张三";
    //公开
    public int age = 18;

    //公开方法和私有方法
    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void test(){
        System.out.println("测试一下");
    }

}

public class Application {

    public static void main(String[] args) {

        //创建子类对象，获取继承父类信息
        Student student = new Student();

        //公开属性
        int age = student.age;
        System.out.println(age);//18
        //私有方法
        String name = student.getName();
        System.out.println(name);//张三
        //父类方法
        student.test();

    }

}

  • super

    • 注意点：

    • 1、super调用父类的构造方法，必须在构造方法的第一个。

    • 2、super必须只能出现在子类的方法或者构造方法中。

    • 3、super和this不能同时调用构造方法。

    • this

      • 代表的对象不同

        • this 本身调用者这个对象

        • 代表父类对象的应用

      • 前提

        • this 没有继承也可以使用

        • super 只能在继承条件才可以使用

      • 构造方法

        • this(); 本类的构造。

        • super(); 父类的构造。

/**
 * @author: ZJG
 * @date: 2022/6/7 22:15
 * @description: 人
 */
public class Person {

//    public Person(){
//        System.out.println("父类无参构造器");
//    }
    public Person(String name){
        System.out.println("父类有参构造器");
    }

    protected String name = "张三";

    //private方法无法被继承！
    public void print(){
        System.out.println("父类Person");
    }

}

/**
 * @author: ZJG
 * @date: 2022/6/7 22:15
 * @description: 老师  自己继承父类，就会拥有父类的全部方法！
 */
public class Teacher extends Person{

    //注意1：父类如果定义有参构造，没有定义无参，那子类无参也不能使用.
    //注意2：父类如果定义有参构造，没有定义无参，那子类可以调用父类有参
    public Teacher(){
        //隐藏de代码：为什么先执行父类无参构造器？
        //调用'super()'必须是构造函数体中的第一条语句
        //不写super();也会默认调用父类无参构造
        super("注意2");
        System.out.println("子类无参构造器");
    }

    private String name = "李四";

    public void test1(){
        System.out.println(name);//李四
        System.out.println(this.name);//李四
        System.out.println(super.name);//张三
    }

    public void print(){
        System.out.println("子类Teacher");
    }

    public void test2(){
        print();//子类Teacher
        this.print();//子类Teacher
        super.print();//父类Person
    }
}

public class Application {

    public static void main(String[] args) {

        Teacher teacher = new Teacher();
        //测试super调用父类属性输出
//        teacher.test1();
        //测试super调用父类方法输出
//        teacher.test2();
        //测试 无参构造器 执行顺序,无需调用
        //1\父类无参构造器 2\子类无参构造器
        //测试 父类有参，子类无参 执行顺序
        //1\父类有参构造器 2\子类无参构造器
    }

}

  • 方法重写

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

      • 方法名必须相同。

      • 参数列表必须相同。

      • 修饰符：范围可以扩大但不能缩小。(public>protected>Default>private)

      • 抛出的异常：范围可被缩小，但不能扩大。ClassNotFoundException -> Exception(大)

    • 重写：子类的方法和父类必须要保持一直，方法体内容可以不同。

    • 为什么重写？

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

      • Alt + insert 注解：@Override

/**
 * @author: ZJG
 * @date: 2022/6/7 23:12
 * @description: 重写都是方法重写，和属性无关。
 */
public class B {

//    public static void test(){
//        System.out.println("父类重写");
//    }

    public void test(){
        System.out.println("父类重写");
    }
}

public class A extends B{

//    public static void test(){
//        System.out.println("子类重写");
//    }

    @Override
    public void test() {
        System.out.println("子类重写");
    }
}

public class Application {

    public static void main(String[] args) {
        /*
           静态方法和非静态方法区别很大。
                静态方法：//方法的调用只能左边，定义的数据类型有关。

          非静态： 重写
         */
        A a = new A();
        a.test();//子类重写

        //父类引用指向子类
        B b = new A();//子类重写了父类的方法
        //静态方法：没被重写，输出结果：//父类重写
        //非静态方法：被重写，输出结果：//子类重写
        b.test();
    }
}

多态

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

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

  • 多态存在的条件：

    • 有继承关系

    • 子类重写父类方法

    • 父类引用指向子类对象

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

public class Person {

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

}

public class Student extends Person{


    @Override
    public void run() {
        System.out.println("重写Student");
    }


    public void eat(){
        System.out.println("学生吃饭");
    }

}

public class Application {

    public static void main(String[] args) {

//        一个对象的实际类型是可以确定的。
//        new Student();
//        new Person();

//        可以指向的引用类型不确定：父类指向子类
        //能调用的都是自己独有和继承父类的
        Student student = new Student();
        //父类可以指向子类，但是不能调用子类独有方法。
        Person person = new Student();
        Object object = new Student();

        student.run();
        person.run();//子类重写父类方法，执行子类。

        //对象能执行那些方法，主要看对象左右类型，和右边关系不大！
        student.eat();
        ((Student) person).eat();

        /*
                注意：
                    1、类型转换异常：classCastException
                    2、属性没有多态
                    3、多态存在条件：继承关系，方法需重写，父类引用指向子类。A a =new B();


                static final private 修饰条件下无法重写。
         */



    }
}

instanceof和类型转换

public class Application {

    public static void main(String[] args) {

        /**	等级
         * 1、Object -> String
         * 2、Object -> Person -> Student
         * 3、Object -> Person -> Teacher
         */

        Object obj = new Student();
        System.out.println(obj instanceof Student);//true
        System.out.println(obj instanceof Person);//true
        System.out.println(obj instanceof Object);//true
        System.out.println(obj instanceof Teacher);//false
        System.out.println(obj instanceof String);//false

        System.out.println("=======================");

        Person per = new Student();
        System.out.println(per instanceof Student);//true
        System.out.println(per instanceof Person);//true
        System.out.println(per instanceof Object);//true
        System.out.println(obj instanceof Teacher);//false
//        System.out.println(per 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(student instanceof String);//编译失败

    }
}

类型转换

public class Student extends Person{

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

}

public class Application {

    public static void main(String[] args) {
//        Person p = new Student();
        //强制转换
        //方式1
//        ((Student) p).go();
        //方式2
//        Student student = (Student) p;
//        student.go();

        System.out.println("==============");
//        Student student = new Student();
//        Person person = student;


        /**
         * 父类引用指向子类的对象
         * 把子类转换为父类。向上转型
         * 把父类转换为子类。向下转型 -强制转换
         * 方便方法的调用，减少重复的代码。
         */
    }
}

static关键字详解

public class Demo01 {

    //静态变量 - 所有类可以访问-内存中只有一个，这个类中所有实例可以访问
    private static int age;
    //非静态变量 - 必须创建对象才可访问
    private double score;


    /*
        静态方法之间可以相互访问，非静态方法可以访问静态方法，但是对方访问不了自己。
     */

    public void test1(){
        test2();
    }

    public static void test2(){
        //访问不了test1()
    }

    /*
        匿名代码块 静态代码块 构造器
     */
    //3
    public Demo01(){
        System.out.println("构造器");
    }

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

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



    public static void main(String[] args) {

//        Demo01 demo01 = new Demo01();
//        System.out.println(age);
//        System.out.println(Demo01.age);//也称类变量
//        System.out.println(demo01.age);
//        System.out.println(demo01.score);

        System.out.println("================");

//        demo01.test1();//非静态方法创建对象访问
//        test2();//相互可以调用

        System.out.println("================");
        //第一遍执行顺序 静态代码块》匿名代码块》构造器
        Demo01 demo02 = new Demo01();
        System.out.println("================");
        //第二遍执行顺序 匿名代码块》构造器
        Demo01 demo03 = new Demo01();

    }
}

5、抽象类和接口

  • abstract 修饰符可以修饰方法和修饰类，如果修饰方法，那么该方法就是抽象方法；如果修饰类，那么该类就是抽象类。

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

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

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

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

抽象类

/**
 * @author: ZJG
 * @date: 2022/6/8 22:02
 * @description: 抽象类(单继承) abstract
 */
public abstract class Person {

    //抽象方法：只有方法名字，没有方法实现。
    public abstract void test1();

    public void test2(){}
    public static void test3(){}

    /*
        1、不能new抽象类，只能靠子类实现它。
        2、抽象类可以写普通方法。
        3、抽象方法必须在抽象类中。
        4、子类如果也是抽象类，可以不实现父类方法。
        
        //存在意义：代码抽象出来，提高开发效率。
     */
}

/**
 * @author: ZJG
 * @date: 2022/6/8 22:02
 * @description: 子类-子类如果也是抽象类，可以不实现父类方法。
 */
public class Student extends Person{

    @Override
    public void test1() {
        
    }
}

接口（interface）

  • 普通类：只有具体实现。

  • 抽象类：具体实现和规范都有。

  • 接口：只有规范。

  • 接口就是规范，定义一组规则，体现现实世界 如果你是。。则必须能。。的思想。

  • 接口本质是契约，就像我们的法律一样。制定好大家遵守。

  • OO精髓，是对对象的抽象。最能体现这一点的就是接口。

/**
 * @author: ZJG
 * @date: 2022/6/8 22:22
 * @description: 接口interface 定义的关键字，都需要有实现类
 */
public interface UserService {

    //接口可定义常量，但是不推荐使用

    //接口中所有定义的方法其实都是抽象的，但是是隐藏的。public abstract
//    示例：public abstract void selectId(int id);

    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);

}

public interface StudentService {

    void select(int id);

}

/**
 * @author: ZJG
 * @date: 2022/6/8 22:23
 * @description: 实现接口的类,就需要重写接口中的方法。
 */
public class UserServiceImpl implements UserService,StudentService {
    @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 select(int id) {

    }
}

6、内部类及OOP实战

  • 内部类就是在一个类的内部再定义一个类，比如：A类中定义一个B类，那么B类相对A类来说就称为内部类，而A类相对B类就是外部类。

  • 1、成员内部类

/**
 * @author: ZJG
 * @date: 2022/6/8 22:39
 * @description: 成员内部类
 */
public class Outer {

    private int age = 10;

    public void test1(){
        System.out.println("外部类");
    }

    public class Inner{
        
        public void test1(){
            System.out.println("内部类");
        }
        //可以获得外部类私有属性
        public void test2(){
            System.out.println(age);
        }
    }

}

public class Application {

    public static void main(String[] args) {
        Outer outer = new Outer();
        //外部类实例化内部类,必须为pulic修饰
        Outer.Inner inner = outer.new Inner();
        inner.test1();
        inner.test2();
    }
}

  • 2、静态内部类

public class Outer {

    private static int age = 10;

    public void test1(){
        System.out.println("外部类");
    }

    public static class Inner{

        public void test1(){
            System.out.println("内部类");
        }
        //可以获得外部类私有属性
        public void test2(){
            System.out.println(age);
        }
    }
}

  • 3、局部内部类

public class Outer {
    
    public void test(){
        class Inner{
            public void test(){
                System.out.println("局部内部类");
            }
        }
        
    }
    
}

  • 4、匿名内部类

public class Outer {

    public static void main(String[] args) {

        new Apple().test();
        User1Service user1Service=new User1Service(){

            @Override
            public void add() {
                
            }
        };
        
    }

}

class Apple{
    public void test(){
        System.out.println("匿名内部类");
    }
}

interface User1Service{
    void add();
}
逆风微笑的咸鱼
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
面向对象（oo）编程
nihaoabu的博客
01-27 688
面向过程（c语言）                    面向对象（java） 线性思维解决（简单事物）           （复杂过程）     1.面向对象编程（oop）的本质：以类的方式组织代码，以对象的方式组织（封装）数据。 类：对对象的抽象 （抽出象的部分）                     对象：具体的事务        先有具体对象，然后抽象各个对象之间象的部分，归纳出
PHP面向对象编程OOP
06-26
深入了解PHP的面向对象编程思想
JAVA基础06——OOP(面向对象编程)、构造器
weixin_44153521的博客
02-12 317
JAVA的核心思想是OOP(Object-Oriented Programming)-----面向对象编程 对于描述复杂的事物，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象的思路来分析整 个系统。但是，具体到微观操作，仍然需要面向过程的思路去处理。 抽象 封装 继承 三大特性 多态 （同一个事物具有不同的形态） 从认识论角度考虑是先有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象。 从代码运行角度考虑是先有类后有对象。类是对象的模板。 ...
Day 7 python OOP面向对象上
deer的博客
03-03 112
OOP面向对象上 介绍 Python——万物皆对象 面向过程——根据业务逻辑自上而下写代码 函数式——功能代码封装到函数中 OOP——将数据与函数绑定到一起，进行封装 类和对象 类Class——具有一组相同或相似属性和方法的移类对象的组合 对象——类的实例化 Class构成： 类名 类属性——数据 类方法——行为 类和对象 实例方法——在类的内部，用def关键字来定义，第一个参数为self【名字表示可以是其他名字，但位置必须被占用】 实例方法归类的实例所有 类属性——在类的内部定义的属性 实例属性——定
Day 8 python OOP面向对象中
deer的博客
03-04 102
OOP面向对象中 析构方法 __ del __()——当对象被删除或销毁时，解释器默认调用的方法 class Animal: def __init__(self, name): # 自动执行 self.name = name print('__init__') pass def __del__(self): # 自动执行 # 释放资源 print('__del__') pass p
Java基础Day06（面向对象编程oop*）
qq_53083806的博客
04-04 204
1.初识面向对象 物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考，最后才对某个分类下的细节进行面向过程的思索。 面向对象适合处理复杂的问题，适合处理需要多人协作的问题 对于描述复杂的事物，为了从宏观上把握，从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是，具体到围观操作，仍需要面向过程的思路去处理 面向对象编程的本质：以类的方式组织代码，以对象的组织（封装数据）。 抽象 三大特性 封装 继承 多态 2.构造器 构造方法的特点 1.必须和类名相
【Python复习巩固 Day4】面向对象编程
King
07-30 197
暑假复习打卡计划
java面向对象编程基础_Java面向对象编程基础
weixin_42332647的博客
02-28 124
一、Java面向对象编程基础1、什么是对象？Object 什么都是对象！只要是客观存在的具体事物，都是对象(汽车、小强、事件、任务、按钮、字体)2、为什么需要面向对象？面向对象能够像分析现实生活问题的方式，来分析和实现计算机问题。拉近了现实世界和计算机世界之间的距离。Scanner sc = new Scanner(System.in);sc.next(); sc.nextInt();对象有什么特...
day51 java面向对象OOP
weixin_45939821的博客
02-21 395
访问修饰符class类名{定义属性定义方法1.1权限访问修饰符：public，默认的1.2类名：见名知义。
【面向对象学习笔记day01】面向对象(OOP)基本概念+面向对象 过程和函数（科普）+植物大战僵尸
汪雯琦的博客
01-21 537
面向对象(OOP)基本概念 文章目录面向对象(OOP)基本概念目标01. 面向对象基本概念1.1 过程和函数（科普）1.2 面相过程 和 面相对象 基本概念1) **面相过程** —— **怎么做**？2) **面向对象** —— **谁来做**？ 面向对象编程 —— Object Oriented Programming 简写 OOP 目标 了解 面向对象 基本概念 01. 面向对象基本概念...
真的可以，用C语言实现面向对象编程OOP
01-27
我们经常说C语言是面向过程的，而C＋＋是面向对象的，然而何为面向对象，什么又是面向过程呢？不管怎么样，我们最原始的目标只有一个就是实现我们所需要的功能，从这一点说它们是殊途同归的。过程与对象只是侧重点...
浅谈Java实现面向对象编程java oop
08-18
主要介绍了浅谈Java实现面向对象编程java oop，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
C语言实现面向对象编程
02-24
面向对象编程（OOP）并不是一种特定的语言或者工具，它只是一种设计方法、设计思想。它表现出来的三个最基本的特性就是封装、继承与多态。很多面向对象的编程语言已经包含这三个特性了，例如Smalltalk、C++、Java。...
android高斯模糊填充imageview背景
cf8833的博客
05-21 552
说明：最近碰到一个需求，安卓app显示在线的url图片，然后imageview没占满的部分，使用该图片的模糊背景填充。
Spring Bean Map之舞
m0_51176516的博客
05-23 484
在Spring框架中，Bean的生命周期管理是其核心功能之一。当Spring容器启动时，它会根据配置信息（如XML配置文件、注解等）来创建和管理Bean实例。这些Bean实例默认会被放置在一个Map数据结构中，以便容器能够快速地根据Bean的名称（或ID）来查找和访问它们。 在Spring的源码中，Bean实例的存储和管理主要依赖于DefaultSingletonBeanRegistry类。这个类内部使用了一个名为singletonObjects的Map来存储单例Bea...
java学习和项目总结
2301_79390585的博客
05-24 411
JRE：JRE是Java 运行时环境，主要包括了两个运行需要的组件：JVM 和 Java 核心类库，如果不进行java开发只想运行就可以只下载JRE。而Java语言，它的代码会先通过javac编译成字节码，再通过jvm将字节码转换成机器码（0和1）执行，即解释运行和编译运行配合使用，所以是混合型。在程序运行之前，通过编译器将源程序编译成机器码可运行的二进制，以后执行这个程序时，就不用再进行编译了。JVM：JVM是java进行编译的虚拟机，是Java 能够跨平台运行的核心。特点：执行速度慢、效率低；
SpringBoot Validation自定义注解之校验指定最小整数
thinkers
05-21 225
1，引入核心关键依赖。
深入理解Java的垃圾回收机制（GC）实现原理
最新发布
微笑听雨
05-25 780
GC是Java虚拟机的重要组成部分，通过自动内存管理，GC提高了Java程序的稳定性和安全性。理解GC的工作原理和不同收集器的特点，有助于选择合适的GC策略，优化应用性能。通过合理配置JVM参数，可以提高GC效率，减少应用停顿时间，提升系统的整体性能。
什么是面向对象编程(OOP)
07-14
面向对象编程（Object-Oriented Programming，简称OOP）是一种编程范式，它将程序中的数据和操作数据的方法组织成对象。在面向对象编程中，程序的设计和实现都围绕着对象展开。 面向对象编程的核心概念包括： 1. ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值