面向对象

最新推荐文章于 2024-10-06 20:16:20 发布

CX330丶w

最新推荐文章于 2024-10-06 20:16:20 发布

阅读量68

点赞数

分类专栏：笔记文章标签： java

本文链接：https://blog.csdn.net/qq_51243773/article/details/113834590

版权

笔记专栏收录该内容

11 篇文章 0 订阅

订阅专栏

面向对象编程

1. 初识面向对象

面向对象编程的本质：以类的方式组织代码，以对象的形式（封装）数据
三大特性：
- 封装
- 继承
- 多态

2. 方法

调用静态方法：类名.方法名();
调用非静态方法：实例化这个类new 对象类型对象名 = 对象值; 类名.方法名(形参);
类实例化后会产生一个自己的对象

值传递

package com.wxj.www.oop;

//值传递
public class Demo01 {
    public static void main(String[] args) {
        int a = 1;
        System.out.println(a);
        Demo01.change(a);
        System.out.println(a);
    }
    //返回值为空
    public static void change(int a){
        a = 10;
    }
}

引用传递

package com.wxj.www.oop;

//引用传递本质是值传递
//对象，内存
public class Demo02 {
    public static void main(String[] args) {
        Person person = new Person();

        System.out.println(person.name); //null

        Demo02.change(person);

        System.out.println(person.name); //错位丶时空
    }
    public static void change(Person person){
        //person是一个对象：指向的 ---> Person person = new person();这是一个具体的人，可以改变属性
        person.name = "错位丶时空";
    }
}
//定义了一个Person类，有一个属性：name
class Person{
    String name;
}

3. 对象的创建分析

使用new关键字创建对象

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

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

package com.wxj.www.oop;

public class Student {

    //属性字段
    String name;
    int age;

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

/*
package com.wxj.www.oop;

//类：抽象的，实例化
//类实例化后会返回一个自己的对象
//student对象就是一个Student类的具体实例

public class Application {
    public static void main(String[] args) {
        Student a = new Student();
        Student b = new Student();

        a.name = "小明";
        a.age = 3;

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

        b.name = "小红";
        b.age = 4;

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


    }
}

 */

构造器

package com.wxj.www.oop;

public class Person1 {
        String name;
        int age;

        public Person1(){
        }
        public Person1(String name){
            this.name = name;
        }

        public Person1(String name,int age) {
            this.name = name;
            this.age = age;
        }
}


/**
 * public class Application1 {
 *     public static void main(String[] args) {
 *         Person1 person1 = new Person1("错位丶时空",19);
 *         System.out.println(person1.name);
 *         System.out.println(person1.age);
 *     }
 * }
 * 构造器：
 *  1.和类名相同
 *  2.没有返回值
 * 作用：
 *  1.new 本质在调用方法
 *  2.初始化对象的值
 * 注意点：
 *  1.定义有参构造器后，如果想使用无参构造器，显示的定义一个无参构造器
 *
 *  Alt+insert快捷键定义构造器*
 *  this.当前类
 * */

4. 面向对象三大特性

封装

高内聚，低耦合
通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为隐藏
属性私有，get/set

package com.wxj.www.oop;

import com.wxj.www.oop.OopDemo01.student;

/*
*1. 提高程序的安全性
*2. 隐藏代码的实现细节
*3. 统一接口
*4. 系统可维护性增加
* */
public class Application {
    public static void main(String[] args) {
        student s1 = new student();

        s1.setName("错位丶时空");
        s1.setAge(8);
        System.out.println(s1.getName());
        System.out.println(s1.getAge());
    }
}


/*
alt+insert //快速创建私有方法
public class student {
    private String name;
    //属性私有
    private int id;
    private char sex;
    private int age;

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if (age>120 || age<0){
            this.age = 3;
        }else {
            this.age = age;
        }
    }

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

    public void setId(int id) {
        this.id = id;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    public String getName() {
        return name;
    }

    public int getId() {
        return id;
    }

    public char getSex() {
        return sex;
    }
}

* */

继承

extends，扩展。子类是父类的扩展
java中类只有单继承，没有多继承
***object***类
权限：public > protected > default > private
ctrl + H查看继承关系
super
- 1，super调用父类的构造方法，必须在构造方法的第一个
- super必须只能出现在子类的方法或者构造方法中
- super和this不能同时调用构造方法
VS
this
- 代表的对象不同：
  
  this ：本身调用这个对象
  
  super ：代表父类对象的应用
- 前提
  
  this：没有继承也可以使用
  
  super：只能在继承条件才可以使用
- 构造方法
  
  this() ;本类的构造
  
  super(); 父类的构造
方法重写（需要有继承关系，子类重写父类的方法）
- 方法名必须相同
- 参数列表必须相同
- 修饰符：范围可以扩大但不能缩小
- 抛出异常：范围，可以被缩小，但不能扩大 ClassNotFoundException --> Exception（大）
- 子类的方法和父类的方法必须要一致，方法体不同
为什么要重写？
- 父类的功能，子类不一定需要，或者不一定满足
- alt+insert ：override重写快捷键

多态

即同一方法可以根据发送对象的不同而采用多种不同的行为方式
一个对象的实际类型是确定的，但可以指向对象的引用类型有很多
多态存在的条件
- 有继承关系
- 子类重写父类的方法
- 父类引用指向子类对象Father f1 = new Son();
多态的注意事项
1. 多态是方法的多态，属性没有多态性
2. 父类和子类，有联系，类型转换异常！ClassCastException！
  - 1.static 方法，属于类，它不属于实例
  - 2.final 常量
  - 3.private方法
  - 以上三种不能实现多态
instanceof
- 判断一个对象是什么类型
强制转换
- 父类引用指向子类的对象
- 把子类转换为父类，向上转型
- 把父类强制转换为子类，向下转型，可能会丢失自己本来的一些方法
- 方便方法调用

5. 抽象类和接口

抽象类

abstract 抽象类抽象方法，只有方法名字，没有方法的实现约束有人帮我们实现需要extend去继承
不能new这个抽象类，只能靠子类去实现它；约束！
抽象类中可以写普通方法
抽象方法必须在抽象类中
new，存在构造器吗？

存在，如果没有提供构造器，编译器会默认提供一个无参构造器

接口

接口的本质是契约
只有规范，自己无法写方法，约束和实现分离
implements可以实现多个接口，实现了接口的类，就需要重写接口中的方法
interface 定义的关键字，接口都需要有实现类
接口中的所有定义的方法其实都是抽象的 public asbract
作用
- 约束
- 定义一些方法，让人实现
- public asbract
- public static final
- 接口不能够被实例化，接口中没有构造方法

总的来说，面向对象是学一些思想