Java面向对象-详细介绍

小灰灰 2024-04-01 12:51 9阅读 0赞

### 01. 面向对象的介绍 ###

面向对象是一种编程思想， 面向对象是基于面向过程，从面向过程思想演化过来的。
    
    面向过程思想： 在完成功能的时候，我们需要关注里面的每一个细节，每一个步骤， 并且里面的每一个细节每个步骤都要有我们自己亲力亲为，由我们自己去实现。
    面向对象思想： 在完成功能的时候，我们只关注结果， 里面的细节，步骤是由别人（对象）帮我们实现的。
    
    面向过程事情是自己做， 面向对象事情是别人做。
    
    面向对象思想的好处：
    	1. 可以把复杂的事情简单化。
    	2. 更加符合人类思考的习惯。
    	3. 从执行者变成了指挥者。

### 02. 面向过程和面向对象的举例 ###

面向对象的举例：
    	买电脑
    		面向过程： 上网查参数 -> 走路来到中关村 -> 找到电脑店 -> 讨价还价 -> 买回电脑
    		面向对象： 让班长去买电脑 -> 交给我们
    	洗衣服：
    		面向过程： 脱衣服 -> 找个盆 -> 放点水 -> 泡一泡 -> 搓一搓 -> 拧一拧 -> 凉一凉 -> 收衣服
    		面向对象： 把衣服交给女朋友命令她去洗衣服 -> 把衣服交给我们

### 03. 类和对象的介绍 ###

![在这里插入图片描述][95890e7909814789906e23b852a420c7.png]

### 04. 学生类的定义 ###

/*
        这是一个学生类，这个类的作用是用来描述(表示)学生这种事物。
            属性：
                姓名，年龄
            行为：
                学习，说话
    
        在类中属性又被称为成员变量。
        在类中行为又被称为成员方法。
    
        成员变量： 定义在类中方法外的变量。
        成员方法： 和之前一样，只不过要去掉static关键字， 在描述现实事物的类中定义方法，要去掉static。
    
        仅仅定义一个学生类是并没有一个具体的学生被创建出来的， 学生类用来对学生这种事物进行描述(说明)， 描述
        了学生这种事物具有姓名和年龄的属性，具备学习和说话的行为。如果想要创建一个具体的学生，那么需要根据这个
        类创建对象。
     */
    public class Student {
        
        //定义成员变量，表示姓名属性
        String name;
        //定义成员变量，表示年龄属性
        int age;
    
        //定义学习方法，表示学习的行为
        public void study() {
        
            System.out.println("好好学习，天天向上");
        }
    
        //定义说话方法，表示说话的行为
        public void say() {
        
            System.out.println("哈哈哈哈哈，能说话真好");
        }
    }

### 05. 学生类的使用 ###

/*
        类的使用步骤
        类是引用数据类型， 使用步骤和之前的Scanner或者Random是一致的。
    
        步骤
            1. 导包
                如果两个类在同一个包下，那么可以省略导包的操作。
            2. 创建对象
                数据类型 对象名 = new 数据类型();
            3. 使用成员
                对象名.成员变量
                对象名.成员方法()
    
        直接输出对象名， 输出的是对象的地址值。
        对象内的属性是有默认值的，对象属性的默认值和数组元素的默认值一样。
            整数  -> 0
            小数  -> 0.0
            布尔  -> false
            字符  -> ' '
            引用  -> null
     */
    public class Demo01StudentTest {
        
        public static void main(String[] args) {
        
            //创建对象
            Student stu = new Student();
            //输出对象名
            System.out.println(stu);
            //获取学生对象的姓名和年龄属性并输出
            System.out.println(stu.name);   //null
            System.out.println(stu.age);    //0
            //给对象的属性重新赋值
            stu.name = "小苍同学";
            stu.age = 36;
            //重新输出对象的属性
            System.out.println(stu.name);   //小苍同学
            System.out.println(stu.age);    //36
            //通过对象调用成员方法
            stu.study();
            stu.say();
        }
    }

### 06.手机类的定义和使用 ###

*  手机类

/*
        手机类， 用来描述手机这种事物。
        属性：
            品牌， 颜色， 价格
        行为：
            打电话， 发短信
     */
    public class Phone {
        
        //品牌
        String brand;
        //颜色
        String color;
        //价格
        int price;
    
        //打电话
        public void call(String name) {
        
            System.out.println("给" + name + "打电话");
        }
    
        //发短信
        public void sendMessage() {
        
            System.out.println("群发短信");
        }
    }

*  测试类

/*
        手机类的测试类。
     */
    public class Demo02StudentTest {
        
        public static void main(String[] args) {
        
            //创建Phone对象
            Phone p = new Phone();
            System.out.println(p);
            //输出Phone对象的各个属性
            System.out.println("品牌：" + p.brand);    //null
            System.out.println("颜色：" + p.color);    //null
            System.out.println("价格：" + p.price);    //0
            //给属性赋值
            p.brand = "波导";
            p.color = "黑色";
            p.price = 998;
            //输出Phone对象的各个属性
            System.out.println("品牌：" + p.brand);    //波导
            System.out.println("颜色：" + p.color);    //黑色
            System.out.println("价格：" + p.price);    //998
            //调用Phone的方法
            p.call("秦始皇");
            p.sendMessage();
        }
    }

### 07. 一个对象的内存图 ###

![在这里插入图片描述][65f710ca2d5c4efa97326cd16cd3f321.png]

### 08. 两个对象的内存图 ###

![在这里插入图片描述][2efc23d8756f40329e5fba1a2d26ea1e.png]

### 09. 成员变量和局部变量的区别 ###

定义位置不同（记住）
    	局部变量： 定义在方法中。
    	成员变量： 定义在类中方法外。
    初始值不同（记住）
    	局部变量： 没有初始值，在使用前必须要赋值。
    	成员变量： 有初始值的，成员变量的初始值和数组元素的初始值一样。
    内存位置不同：
    	局部变量： 跟随方法保存在栈内存中。
    	成员变量： 跟随方法保存在堆内存中。
    生命周期不同
    	局部变量： 当代码执行完定义变量的代码时就会产生， 离开自己的作用域该变量就会消失
    	成员变量： 在创建对象的时候跟随对象产生， 在对象消失的时候跟随对象消失。

### 10. private关键字以及get和set方法 ###

学生类

/*
        学生类
        属性：
            姓名，年龄
        行为：
            show方法，展示自己的行为，调用show方法后，可以输出自己的姓名和年龄。
    
        目前因为可以直接访问到对象的属性，所以可以给对象的属性赋值成任何内容。
        如果我们不让外界直接访问到这个对象的属性，那么就可以进行限制了。
    
        private关键字
            1. private是一个权限修饰符
            2. 表示私有，被private修饰的成员只能在本类中访问。
            3. private可以修饰成员变量，也可以修饰成员方法。
    
        如果类中的属性使用private修饰了，那么该属性无法在外界使用了，这样也是不行的，我们要提供一些方式让外界	  去使用这个变量。
        我们可以提供一个方法，让外界给private修饰的属性赋值， 这个方法名叫做setXXX
        我们还要提供一个方法，让外界获取private修饰的属性值， 这个方法名叫做getXXX
     */
    public class Student {
        
        //姓名
        String name;//小波老师
        //年龄
        private int age;//18
    
        //定义方法，用来让外界获取age属性值
        public int getAge() {
        
            return age;
        }
    
        //定义方法，用来让外界给age属性赋值
        public void setAge(int a) {
        
            //使用if进行判断，如果传递过来的年龄是合法的年龄，再赋值
            if(a > 0 && a <= 200) {
        
                age = a;
            } else {
        
                System.out.println("年龄有误");
            }
        }
        //show方法，可以将自己的姓名和年龄输出
        public void show() {
        
            System.out.println("姓名：" + name + "，年龄：" + age);
        }
    }

测试类：

/*
        学生类的测试类
     */
    public class Demo01StudentTest {
        
        public static void main(String[] args) {
        
            //创建学生对象
            Student stu = new Student();
            //给学生对象的属性赋值
            stu.name = "小波老师";
            stu.setAge(18);
    
            //调用对象的show方法，输出姓名年龄
            stu.show();
    
            //单独获取stu的age属性值
            System.out.println(stu.getAge());
        }
    }

### 11. 标准的private代码 ###

/*
        学生类
    
        属性：
            姓名，年龄。 属性要加私有
        方法：
            get/set
    
        set方法没有返回值，有参数。
        get方法有返回值，没有参数。
     */
    public class Student {
        
        //定义姓名和年龄属性
        private String name;
        private int age;
    
        //getName让外界获取name属性的值
        public String getName() {
        
            return name;
        }
    
        //setName 让外界给name属性赋值
        public void setName(String n) {
        
            name = n;
        }
    
        //getAge
        public int getAge() {
        
            return age;
        }
    
        //setAge
        public void setAge(int a) {
        
            age = a;
        }
    }

/*
        测试类
     */
    public class Demo01StudentTest {
        
        public static void main(String[] args) {
        
            //创建学生对象
            Student stu = new Student();
            //给属性赋值
            stu.setName("小泽老师");
            stu.setAge(24);
            //获取属性的值，然后输出
            System.out.println("姓名：" + stu.getName());
            System.out.println("年龄：" + stu.getAge());
        }
    }

### 12. 封装的概述 ###

封装是面向对象三大特征之一， 另外两个分别是继承和多态。
    封装指的是隐藏具体的实现，然后提供公共的对外访问方式。
    
    目前代码封装的体现：
    	使用private将属性私有(隐藏)， 然后提供了get/set(访问方式)
    
    封装的好处：
    	1. 提高代码的安全性。
    	2. 可以提高代码的复用性

### 13. this关键字的作用 ###

*  Student类

/*
        成员变量和局部变量允许重名。
    
        如果局部变量和成员变量同名，那么访问到时局部变量。
    
        如果在一个类中局部变量和成员变量同名，那么可以使用this去区分它们。
        使用this表示的是成员变量，格式：
            this.变量名
    
        this可以解决的问题： 局部变量和成员变量同名的问题。
        this的含义： this所在的方法是通过哪个对象调用的，this就表示哪个对象(this中真正存放的是对象的地址			    值，或者说对象的引用)
     */
    public class Student {
        
        //定义姓名和年龄属性
        private String name;//"小泷老师"
        private int age;
    
        public String getName() {
        
            return name;
        }
    
        public void setName(String name) {
        //="小泷老师"
            System.out.println("this:" + this);
            this.name = name;
        }
    
        public int getAge() {
        
            return age;
        }
    
        public void setAge(int age) {
        
            this.age = age;
        }
    }

*  测试类

/*
        学生类的测试类
     */
    public class Demo01StudentTest {
        
        public static void main(String[] args) {
        
            //创建Student对象
            Student stu = new Student();
            System.out.println("stu:" + stu);
            //给属性赋值。
            stu.setName("小泷老师");
            stu.setAge(30);
            //输出该属性的值
            System.out.println("姓名：" + stu.getName() + ", 年龄：" + stu.getAge());
        }
    }

### 14. 构造方法的介绍 ###

*  Student类

/*
        构造方法作用： 用来在创建对象的时候给属性赋值。
    
        构造方法的格式：
            public 构造方法名(参数列表) {
                构造方法体;
            }
            1. 构造方法不需要写返回值类型，连void都不用写
            2. 构造方法名必须和类名一致
            3. 构造方法不能return任何东西，但是单独写一个return是可以的， return一般省略。
    
        构造方法的调用：
            构造方法是在创建对象的时候自动调用的。
            new 数据类型(); 这个操作是在创建对象， 此时就会调用构造方法。
            在创建对象的时候小括号中我们可以传递一些参数， 程序会根据传递的参数调用对应的构造方法。
    
        构造方法的注意事项：
            1. 如果在一个类中我们没有给出构造方法，那么系统会帮我们提供一个空参数的构造方法。
            2. 如果在一个类中我们给出了构造方法，那么系统就不会帮我们提供这个空参数的构造方法了。
            3. 构造方法支持重载。
     */
    public class Student {
        
        //提供两个属性(姓名，年龄)
        private String name; //小明同学
        private int age; //20
    
        //提供show方法，用来输出学生对象的姓名和年龄。
        public void show() {
        
            System.out.println("name:" + name + ", age:" + age);
        }
    
        //提供构造方法，用来在创建对象的时候给属性赋值
        public Student(String name, int age) {
        //name="小明同学" age=20
            this.name = name;
            this.age = age;
        }
    
        //为了保证以最常用的方式也能创建对象，手动提供一个空参数的构造方法
        public Student() {
        
    
        }
    
    }

*  测试类

/*
        构造方法的调用
            构造方法是在创建对象的时候自动调用的。
            new 数据类型(参数)
     */
    public class Demo01StudentTest {
        
        public static void main(String[] args) {
        
            //创建Student对象， 执行空参数的构造方法
            //因为创建对象的时候小括号中没有写任何东西，那么使用的就是空参数的构造方法。
            //Student s1 = new Student();
    
            //创建Student对象， 执行一个参数是字符串的构造方法
            //因为创建对象的时候小括号中写的是一个字符串，所以使用的就是一个参数是字符串的构造方法。
            //Student s2 = new Student("你好");
    
            //Student s3 = new Student();
    
            //调用一个参数是int的构造方法
            //Student s4 = new Student(100);
    
            //创建对象，在创建对象的时候直接给属性赋值
            Student stu = new Student("小明同学", 20);
            stu.show();
    
    
        }
    }

### 15. 标准的学生类的定义 ###

*  Student类

/*
        javabean就是Java编写类的规范， 只要一个类符合这些规范，那么这个类就可以称为是一个Javabean。
    
        Javabean规范
            1. 将属性私有。
            2. 提供get/set方法
            3. 提供空参数的构造方法(必须)，提供有参数的构造方法(选做，现阶段建议做)
    
        定义一个学生类，提供姓名和年龄属性， 要求满足Javabean规范。
     */
    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 void setName(String name) {
        
            this.name = name;
        }
    
        public int getAge() {
        
            return age;
        }
    
        public void setAge(int age) {
        
            this.age = age;
        }
    
    }

*  测试类

public class Demo01StudentTest {
        
        public static void main(String[] args) {
        
            //使用空参数构造方法创建Student对象
            Student stu = new Student();
            //给stu的属性赋值
            stu.setName("宝强同学");
            stu.setAge(25);
            //输出属性的值
            System.out.println("姓名：" + stu.getName() + "，年龄：" + stu.getAge());
            System.out.println("==========================");
    
            //使用有参数的构造方法创建Student对象，创建对象的时候直接给属性赋值
            Student stu2 = new Student("乃亮同学", 40);
            //stu2.setAge(41);
            System.out.println("姓名：" + stu2.getName() + "，年龄：" + stu2.getAge());
    
        }
    }

### 16. 航班信息 ###

/*
        航班类
            属性：航班号，航空公司，起点站，终点站，票价
            方法：get/set/打印航空信息方法
     */
    public class Flight {
        
        //航班号
        private String flightNum;
        //航空公司
        private String airline;
        //起点站
        private String from;
        //终点站
        private String to;
        //票价
        private int fare;
    
        //打印航空信息方法
        public void print() {
        
            System.out.println("航班号：" + flightNum + "，航空公司：" + airline + "，起点站：" + from + "，终点站：" + to + "，票价：" + fare);
        }
    
    
        public Flight() {
        
        }
    
        public Flight(String flightNum, String airline, String from, String to, int fare) {
        
            this.flightNum = flightNum;
            this.airline = airline;
            this.from = from;
            this.to = to;
            this.fare = fare;
        }
    
        public String getFlightNum() {
        
            return flightNum;
        }
    
        public void setFlightNum(String flightNum) {
        
            this.flightNum = flightNum;
        }
    
        public String getAirline() {
        
            return airline;
        }
    
        public void setAirline(String airline) {
        
            this.airline = airline;
        }
    
        public String getFrom() {
        
            return from;
        }
    
        public void setFrom(String from) {
        
            this.from = from;
        }
    
        public String getTo() {
        
            return to;
        }
    
        public void setTo(String to) {
        
            this.to = to;
        }
    
        public int getFare() {
        
            return fare;
        }
    
        public void setFare(int fare) {
        
            this.fare = fare;
        }
    }

public class Demo01Test {
        
        public static void main(String[] args) {
        
            //创建航班对象
            Flight flight = new Flight();
            //给属性赋值
            flight.setFlightNum("666");
            flight.setAirline("航空");
            flight.setFrom("北京");
            flight.setTo("火星");
            flight.setFare(22980);
            //显示航班信息
            flight.print();
        }
    }

[95890e7909814789906e23b852a420c7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/73fa38b2ba524a24b52232562dd5e609.png
[65f710ca2d5c4efa97326cd16cd3f321.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/14a16ef70b4846b6a4f87b5cc6590592.png
[2efc23d8756f40329e5fba1a2d26ea1e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/0f4f1a395c81420db91f18cb501901f0.png