面向对象的学习

大啊林

已于 2022-02-10 17:29:35 修改

阅读量466

点赞数 1

文章标签： java 开发语言后端

于 2022-02-08 23:40:56 首次发布

本文链接：https://blog.csdn.net/weixin_55350383/article/details/122833450

版权

面向对象（上）

Java面向对象学习的三条主线

java类及类的成员：**属性、方法、构造器；**代码块、内部类
**面向对象的三大特征：**封装、继承、多态
其他关键字：this、super、static、final、abstract、interface、package、import

面向对象与面向过程

面向过程(POP)与面向对象（OOP）

面向过程：强调的是功能、以函数为最小单位，考虑怎么做
面向对象：强调具备了功能的对象，以类/对象为最小单位，考虑谁来做

面向对象的思维概述：

程序员从面相过程的执行着转化成了面向对象的指挥者
面向对象分析方法分析问题的思路和步骤：
1. 根据问题需要，选择问题所针对的现实世界中的实体。
2. 从实体中寻找解决问题相关的属性和功能，这些属性和功能就形成了概念世界中的类。
3. 把抽象的实体用计算机语言进行描述，形成计算机世界中类的定义。即接著某种程序语言，把类构造成计算机能够识别和处理的数据结构。
4. 将类实例化成计算机世界中的对象。对象是计算机世界中解决问题的最终工具。

Java语言中的基本元素：类和对象

类和(Class)和对象(Object)是面向对象的和性概念
- 类是对一类事物的描述，是抽象的、概念上的定义
- 对象是实际存在的该类事物的每个个体，因而也称为实例(instance)
万事万物皆对象

类

比如人、猪、狗、玩具、水果，对某一类实物的抽象
面向对象程序设计的重点是对类的设计
类的设计，就是设计类的成员
- 现实世界中的生物体，达到鲸鱼，小到蚂蚁，都是有最基本的细胞构成的。同理，Java代码世界是由诸多个不同功能的类构成的。
- 类中的两个主要的成员：属性和方法
属性=成员变量=field=域、字段
方法=成员方法=函数=method

类和对象的创建与使用

创建类，设计类的成员
创建类的对象
通过“对象.属性”或“对象.方法”调用对象的结构

public class Mini {
   
    public static void main(String[] args) {
   
        //实例化对象
        Person p1 = new Person();
        p1.name = "小狗蛋";
        p1.sex = '女';
        p1.age = 24;
        p1.height = 158;
        p1.eat();
        p1.sleep();
        p1.talk("中文");
    }
    }
class Person {
   
    //属性：名字、性别、身高
    String name;
    int age;
    char sex;
    double height;
    //方法：睡觉、吃法、说话
    public void eat(){
   
        System.out.println("人会吃饭");
    }
    public void sleep(){
   
        System.out.println("人要睡觉");
    }
    public void talk(String language){
   
        System.out.println("中国人说的是"+language);
    }
}

如果创建了一个类的多个对象，则每个对象都独立拥有一套属性。（非static的）

也就是说，我们修改了一个对象的属性，并不会影响另一个对象的属性

对象的内存解析

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TOGaTTUu-1644334828455)(C:\Users\lin\AppData\Roaming\Typora\typora-user-images\image-20220111212301417.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-O5LeUIsv-1644334828456)(C:\Users\lin\AppData\Roaming\Typora\typora-user-images\image-20220111213339194.png)]

属性（成员变量）与局部变量的对比

相同点
1. 定义变量的格式相同：数据类型变量名 = 变量值;
2. 先声明，后使用
3. 变量都有其对应的作用域
不同点
1. 定义的位置不同：
  - 成员变量：直接定义在类中的变量，在类的大括号{}里面
  - 局部变量：声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量
2. 关于权限修饰符的不同：
  - 属性可以在声明属性时，使用权限修饰符指明其权限。
  - 常用的权限修饰符：public、private、protected 、缺省(未声明权限修饰符)–>封装性
  - 局部变量不能使用权限修饰符，他的权限与方法的权限一致。
3. 默认初始化值的情况：
  - 属性：类的属性，根据其基本类型，都有默认初始化值。
    - 整形（byte、short、int、long）：0
    - 浮点型（float、double）：0.0
    - 字符型（char）：0或\u0000
    - 引用数据类型（类、数组、接口）：null
  - 局部变量：没有默认初始化值
    - 意味着我们在调用局部变量时必须先赋值public （public static void main(String[] args) { //这里面的args（形式参数）也是局部变量）
    - 形式参数我们在调用时再赋值即可
4. 在内存中加载的位置不同
  1. 属性：加载到堆空间中（非static）
  2. 局部变量：加载到栈中

方法的举例和声明的格式

类中方法的声明和使用

方法：描述该类具有的功能
比如：
- Math类：sqrt()\random()…
- Scanner类：nextXxx()…
- Arrays类：sort()\binarySearch()\toString()\equals()…

public class Text {
   

    public static void main(String[] args) {
   

    }
    class Customer{
   
        //属性
        String name;
        int age;
        boolean married;
        //方法的声明：权限修饰符 返回值 方法名(形式参数列表){方法体}
        public void eat(String food){
   
            System.out.println("客户去吃饭了，吃的是"+food);
        }
        public void sleep(){
   
            System.out.println("客户现在在休息");
        }
        public String getName(){
   
            return name;
        }
        public String getNation(String nation){
   
            String info ="我的国籍是："+ nation;
            return info;
        }
    }
}

方法声明的说明

关于权限修饰符（四个）：private、public、缺省、protected–>封装性再细讲
返回值类型：有返回值 & 没有返回值
- **如果方法有返回值：**必须在方法声明时指定返回值的类型。同时在方法中需要使用return 指定返回值类型的数据。
- **没有返回值：**在声明方法时，则需要使用void来表示。农场没有返回值的方法中，不需要使用return。也可以使用“return;”来结束方法，只有结束方法的作用，后面的语句不能执行。
方法名：属于标识符，需要满足首字母大写，驼峰原则，需要见名知意。
形参列表：方法可以声明0个、一个或者多个形参
1. 格式：数据类型1 形参1，数据类型2 形参2，…
2. 我们定义方法时，是否需要定义形参：视情况而定
方法体：具体方法的实现

return关键字的使用

使用范围：使用在方法体中
作用：
1. 结束方法
2. 针对有返回值类型的方法，使用“return 数据”方法返回所要的数据
return关键字后面不能声明语句，这一点和break是一样的

方法的使用

方法在使用中可以调用当前类的属性及当前类中的方法
- 可以调用别的方法
- 也可以调用自己（递归）

利用面向对象的方法，设计Circle类计算园的面积

package OOP.Circle;
//利用面向对象的方法，设计Circle类计算园的面积
public class CircleText {
   
    public static void main(String[] args) {
   
        Circle cir = new Circle();
        cir.radius = 3;
//        double area = cir.getArea();
//        System.out.println(area);
        cir.getArea();
    }
}
//方法一
//class Circle{
   
//        double radius;
//        public double getArea(){
   
//            double area = Math.PI*radius*radius;
//            return area;
//        }
//
//}
//方法二
class Circle{
   
    double radius;
    public void getArea(){
   
        System.out.println("圆的面积为："+Math.PI*radius*radius);

    }

}

打印自定义矩形

package OOP.Exer;
import java.util.Scanner;
/*
3.1编写程序，声明一个method方法，在方法中打印一个10×8的“*”矩形，在main方法中调用该方法。
3.2修改上面一个程序，除了打印矩形外，再计算该矩形的面积
并将其作为返回值，在main方法中调用该方法，接收返回的面积并打印
3.3修改上一个程序，在method方法提供m和n两个参数，方法中打印一个m×n的矩形，将其作为返回值，在main方法中调用该方法，接收返回的面积并打印
 */
public class RectangleText {
   
    public static void main(String[] args) {
   
        Rectangle rect = new Rectangle();
        System.out.println("请输入长度m的值：");
        rect.m = rect.getVal();
        System.out.println("请输入宽度n的值：");
        rect.n = rect.getVal();
        rect.diagramPrint();
        rect.printArea();
    }
}

class Rectangle{
   
    int m;
    int n;
    //输出面积
    public void printArea(){
   
        System.out.println("矩形面积为："+m*n);
    }
    //打印图形
    public void diagramPrint(){
   
        System.out.println("打印矩形：");
        for (int i = 0; i < m; i++) {
   
            for (int j = 0; j < n; j++) {
   
                System.out.print("*\t");
            }
            System.out.println();
        }
    }
    //创建一个从键盘接收数据的方法
    public int getVal(){
   
        int val = 0;
        for (; ; ) {
   
            Scanner sca = new Scanner(System.in);
            if (sca.hasNextInt()){
   
                val= sca.nextInt();
                return val;
            }else {
   
                System.out.println("请输入正确的数据类型！");
            }
        }
    }
}

打印学生信息

package OOP.Student;
    /*定义类Student，包含三个属性：学号number(int)，年级state(int)，成绩score(int)。
创建20个学生对象，学号为1到20，年级和成绩都有随机数确定。
1.打印出3年级（state=3）的学生信息。
2.使用冒泡排序将学生按成绩排序，并遍历所有学生的信息
 */
public class StudentText {
   
    public static void main(String[] args) {
   
        Student[] student = new Student[20];//创建一个Student类型的数组
        for (int i = 0; i < student.length; i++) {
   
            student[i] = new Student();//给数组元素赋值，这个值就是Student类型的值。
            student[i].number = i+1;
            student[i].state = (int) (Math.random()*(6-1+1)+1);
            student[i].score = (int) (Math.random()*(100-0+1)+0);
            //输出三年级学生的信息
            if (student[i].state == 3){
   
                student[i].info();
            }
        }
        //使用冒泡排序以成绩高低对学生进行排序
        for (int i = 0; i < student.length-1; i++) {
   
            for (int j = 0; j < student.length-1-i ; j++) {
   
                if (student[j].score>student[j+1].score){
   
                Student temp = student[j];
                student[j] = student[j+1];
                student[j+1] = temp;
                }
            }
        }
        //打印所有学生的信息
        for (int i = 0; i < student.length-1; i++) {
   
            student[i].info();
        }
    }
}
//创建类
class Student{
   
    int number;//学号
    int state;//年级
    int score;//成绩
    //打印学生信息的方法
    public void info(){
   
        System.out.println("学号"+number+"\t年级："+state+"\t成绩："+score);
    }
}

改进

package

最低0.47元/天解锁文章

大啊林

关注

1
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
面向对象的学习

面向对象（上）Java面向对象学习的三条主线java类及类的成员：**属性、方法、构造器；**代码块、内部类**面向对象的三大特征：**封装、继承、多态其他关键字：this、super、static、final、abstract、interface、package、import面向对象与面向过程面向过程(POP)与面向对象（OOP）面向过程：强调的是功能、以函数为最小单位，考虑怎么做面向对象：强调具备了功能的对象，以类/对象为最小单位，考虑谁来做面向对象的思维概述：程序
复制链接

扫一扫