1.面向对象编程

冰蓝星

已于 2023-12-21 00:08:00 修改

阅读量864

点赞数 28

分类专栏： Java 文章标签： java 开发语言

于 2023-12-06 18:39:42 首次发布

本文链接：https://blog.csdn.net/qq_51567793/article/details/134835543

版权

Java 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

面向对象编程

一、面向对象的方式

通过创建一个一个的对象来实现

二、开发步骤

定义描述事物的类：成员变量、成员方法
创建对象
使用对象：存储数据(成员变量)、处理数据(成员方法)

三、概念

1.类：是对现实生活中一类具有共同属性和行为的事物的抽象，确定对象将会拥有的 [属性] 和 [行为]

2.对象：是能够看得到摸得着的真实存在的实体

类是对象的抽象，对象是类的实体

本质上是一种特殊的数据结构，类似于生活中的表格

是根据描述事物的类，创建出来的具体的实例，new 出来的

3.对象的属性和行为

属性：对象具有的各种特征，每个对象的每个属性都拥有特定的值

在类中通过成员变量来体现(类中方法外的变量)
行为：对象能够执行的操作

在类中通过成员方法来体现

4.案例

学生实体类

//1.定义描述学生的类
public class Student {
    String name;
    int chinese;
    int math;

    //处理数据,定义方法时候注意先把 static 关键字去掉
    //定义计算总分方法
    public void printSum() {
        System.out.println(name + "同学的总分是：" + (chinese + math));
    }
    //定义计算平均成绩方法
    public void printAvg() {
        System.out.println(name + "同学的平均成绩是：" + (chinese + math) / 2.0);
    }
}

主方法

public class scoreAvg {
    public static void main(String[] args) {
        //2.创建对象
        Student s1 = new Student();
        s1.name = "小明";
        s1.chinese = 99;
        s1.math = 87;
        //3.处理数据
        s1.printSum();
        s1.printAvg();

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

        Student s2 = new Student();
        s2.name = "小李";
        s2.chinese = 100;
        s2.math = 80;
        s2.printSum();
        s2.printAvg();
    }
}

四、对象在计算机中的执行原理

五、类和对象的注意事项

类名建议使用英文单词，首字母大写，满足驼峰模式，且要有意义，比如：Student、Car…
类中定义的变量也称为成员变量(对象的属性)，类中定义的方法也称为成员方法(对象的行为)
成员变量本身存在默认值，在定义成员变量时一般来说不需要赋默认值(没有意义)

数据类型明细默认值
基本类型 byte、short、char、int、long
float、double
boolean 0
0.0
false
引用类型数组、String、类 null
一个Java文件中，可以写多个class类，但只能一个用 public 修饰，且public修饰的类名必须为Java文件名
对象与对象之间的数据不会相互影响，但多个变量指向同一个对象时就会相互影响了
如果某个对象没有一个变量指向它(null)，则该对象无法被操作了，该对象会成为所谓的 垃圾对象
- 注意：当堆内存中的对象，没有被任何变量引用(指向)时，就会被判定为内存中的“垃圾”
- Java 存在自动垃圾回收机制，会自动清除掉垃圾对象，程序员不用操心

数据类型	明细	默认值
基本类型	byte、short、char、int、long float、double boolean	0 0.0 false
引用类型	数组、String、类	null

六、成员变量和局部变量的区别

区别	成员变量	局部变量
类中位置不同	类中方法外	方法内或者方法声明上
初始化值不同	有默认值,不需要初始化赋值	没有默认的初始化值,必须先定义赋值,才能使用
内存中位置不同	堆内存	栈内存
作用域不同	整个对象	在所归属的大括号中
生命周期不同	与对象共存亡	随着方法的调用(调用完毕)而存在(消失)

七、this关键字

this 就是一个变量，它所在的方法被哪个对象调用，this就代表哪个对象
this 主要用来解决：变量名称冲突问题【this.变量 <==> 对象.变量 (访问的是成员变量)】

产生冲突原因：使用任何变量时，遵循就近原则(先去局部范围找、再去成员范围找)
this 访问的变量只能是成员变量
案例：

public class ThisDemo {
    public static void main(String[] args) {
        Stu s1 = new Stu();
        s1.score = 200;
        s1.school(250);
        System.out.println("---------------");
        Stu s2 = new Stu();
        s2.score = 300;
        s2.school(250);
    }
}
class Stu {
    double score;
    public void school(double score){
        if(this.score >= score){ //this.score代表 s1,s2 对象
            System.out.println("考上了");
        }else{
            System.out.println("没有考上");
        }
    }
}

八、构造器/构造方法

构造器是一种特殊的方法：
1.没有返回值类型
2.方法名和类名必须相同

1.构造器的调用

new 类()时，1>创建该类对象 2>对象会去调用构造器

2.构造器的常见使用场景

构造对象时，同时完成对对象成员变量的初始化赋值

3.构造器的注意事项

类在设计时，如果不写构造器，Java是会为类自动生成一个无参构造器
一旦定义了有参构造器，Java就不会帮我们的类自动生成无参构造器了，此时就建议自己手写一个无参构造器出来了

4.案例

1.学生类

//学生实体类
public class Student {
    String name;
    int age;
    //无参构造器
    public Student(){
        System.out.println("无参构造器执行---");

    }
    //有参构造器
    public Student(String name, int age){
        this.name = name;
        this.age = age;
        System.out.println("有参构造器执行---");
        System.out.println(this.name+":"+this.age);
    }
}

2.main主体类

//main 主方法
public class conDemo1 {
    public static void main(String[] args) {
        Student s1 = new Student();// 在创建对象的时候，对象会调用构造器
        //赋值
        s1.name = "小明";
        s1.age = 24;

        //有参构造器
        new Student("小李", 22);//传参创建
    }
}

九、封装

1.概念

面向对象的三大特征之一(封装、继承、多态)
- 描述一类事物时，把要存储的数据(成员变量)，以及数据的处理(成员方法)，设计到一个类中的过程，就称之为封装(定义事物类的过程)

2.合理封装

合理隐藏：private私有，外界不能直接访问
合理暴露：public公共

设置隐藏(private变量)后，外界访问需要通过封装类中提供的公共public的set(设置值)和get(获取值)方法进行访问

3.封装原则

将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问
成员变量private，提供对应的==getXxx()/setXxx()==方法

4.封装的好处

通过方法来控制成员变量的操作，提高了代码的安全性
把代码用方法进行封装，提高了代码的复用性

5.案例

1.封装的类

//封装的类
public class Car {
    private String brand;//品牌
    private double price;//价格
    private String engine;//发动机
    //定义公共的修改成员变量的方法 public .. set*
    public void setPrice(double price){
        //限定price的条件
        if(price >= 100000){//可以在 set方法中 设定成员变量的复制规范
            this.price = price;
        }
    }
    //定义公共的获取成员变量的方法 public .. get*
    public double getPrice(){
        return this.price;
    }
    public void setBrand(String brand){
        if(brand == "红旗"){
            this.brand = brand;
        }
    }
    public String getBrand(){
        return this.brand;
    }
    public void setEngine(String engine){
        this.engine = engine;
    }
    public String getEngine(){
        return this.engine;
    }
    public void info(){
        System.out.println("品牌 "+brand+"价格 "+price);
    }
}

2.main方法类

//main方法
public class fengZ {
    public static void main(String[] args) {
        Car c1 = new Car();
        c1.setBrand("红旗");//使用封装类中提供的 public set方法进行赋值
        c1.setPrice(9999999);
        c1.setEngine("红旗牌发动机");
		//访问 private 成员变量时，需要借助封装类提供的 公共public的set和get方法进行访问
        System.out.println("品牌："+c1.getBrand()+"价格："+c1.getPrice()+"发动机"+ c1.getEngine());
        c1.info();
    }
}

十、实体JavaBean

1.实体类

就是一种特殊形式的类
1. 这个类中的成员变量都私有，并且要对外提供相应的**getXxx(),setXxx()**方法
2. 类中必须要有一个公共的无参构造器(建议同时提供有参构造器)

2.实体类的作用

只负责数据的存储，而对数据的处理交给对应的操作类来完成，以实现数据和数据业务处理相分离

3.业务分离

实体类：存储数据
操作类：处理数据
测试类：测试以上两个类正确性

4.案例

1.学生实体类

//学生实体类:成员变量全都私有(private)、包含无参 有参构造器、 包含get set方法
public class Student {
    private String name;
    private int age;
    //无参构造
    public Student() {
    }
    //有参构造
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    //get、set方法
    public String getName() {
        return name;
    }
    public int getAge() {
        return age;
    }
    public void setName(String name) {
        this.name = name;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

2.操作方法类

//操作方法类
public class StudentOperatot {
    //判断学生是否成年
    public void isAge(Student s){
        if(s.getAge() >= 18){
            System.out.println(s.getName()+"学生成年了");
        }else{
            System.out.println(s.getName()+"学生未成年");
        }
    }
}

3.测试类

//测试类
public class test {
    public static void main(String[] args) {
        Student sc = new Student();
        sc.setName("小明");
        sc.setAge(11);
        StudentOperatot so = new StudentOperatot();
        so.isAge(sc);
    }
}

十一、面向对象综合案例

需求：

电影实体类

package duixiangZonghe;
//电影实体类
public class Movie {
    private int id;//编号
    private String name;//名称
    private String url;//图片地址
    private double price;//价格
    private double score;//评分
	//无参构造器
    public Movie() {
    }
	//有参构造器
    public Movie(int id, String name, String url, double price, double score) {
        this.id = id;
        this.name = name;
        this.url = url;
        this.price = price;
        this.score = score;
    }
	//set 和 get 方法
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getUrl() {
        return url;
    }
    public void setUrl(String url) {
        this.url = url;
    }
    public double getPrice() {
        return price;
    }
    public void setPrice(double price) {
        this.price = price;
    }
    public double getScore() {
        return score;
    }
    public void setScore(double score) {
        this.score = score;
    }
}

操作类

package duixiangZonghe;

//操作类
public class MovieOperator {
    //展示所有电影信息
    public void showMovies(Movie[] mv) {//所有信息展示，使用数组
        for (int i = 0; i < mv.length; i++) {
            System.out.println(mv[i].getName() + " " + mv[i].getPrice());
        }
    }

    //根据id 查询对应的电影的全部信息
    public void showInfo(int id, Movie[] mv) {//查询时 需要查询的id和查询对象 mv数组
        for (int i = 0; i < mv.length; i++) {
            if (mv[i].getId() == id) {
                System.out.println(mv[i].getName() + " " + mv[i].getUrl() + " " + mv[i].getPrice() + " " + mv[i].getScore());
            }
        }
    }
}

测试类

package duixiangZonghe;
//测试类
public class Test {
    public static void main(String[] args) {
        //定义三部电影对象，将其保存在一个数组中
        Movie m1 = new Movie(1,"独行月球01","https://201.jpg",99,9.1);
        Movie m2 = new Movie(2,"独行月球02","https://202.jpg",88,8.1);
        Movie m3 = new Movie(3,"独行月球03","https://203.jpg",77,7.1);
        //将Movie的全部信息保存在一个数组 mv 中，类型是 Movie
        Movie[] mv = {m1, m2, m3};
        //定义操作类对象
        MovieOperator arr = new MovieOperator();
        arr.showMovies(mv);
        arr.showInfo(3,mv);
    }
}