JAVA面向对象编程入门

已于 2022-07-13 11:39:11 修改
阅读量343 收藏 2
点赞数 1
分类专栏： Java 文章标签： java 面向对象
于 2022-07-12 11:38:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_62684026/article/details/125732977
版权

目录

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

面向对象的三大特征

二、“人把大象装冰箱”

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

一.设计类

二.类和对象的使用

三、属性

四、对象的内存解析

对象的创建和使用：内存解析

类中属性的使用

类中方法的声明和使用

对象数组的题目：

一、理解"万事万物皆对象"

二、内存解析说明

匿名对象的使用 

 对比

UML类图  

this关键字的使用：

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

1.Java类及类的成员：属性、方法、构造器、代码块、内部类

2.面向对象的三大特征：封装性、继承性、多态性、（抽象性）

3.其他关键字：this、super、static、final、abstract、interface、package、import等。

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

二者都是一种思想，面向对象是相对于面向过程而言的。面向过程，强调的是功能行为，以函数为最小单位，考虑怎么做。面向对象，将功能封装进对象，强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。

面向对象更加强调运用人类在日常的逻辑思维中采用的思想方法与原则，如抽象、分类、继承、聚合、多态等。

面向对象的三大特征

封装（encapsulation）

继承（inheritance）

多态（polymorphism）

面向对象：object oriented programming

面向过程：procedure oriented programming

二、“人把大象装冰箱”

1.面向过程：强调的是功能行为，以函数为最小单位，考虑怎么做

①把冰箱门打开

②抬起大象，塞进冰箱

③把冰箱门关闭

2.面向对象：强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。

人{

打开（冰箱门）{

冰箱.开门();

}

抬起(大象){

大象.进入(冰箱);

}

关闭(冰箱){

冰箱.闭合();

}

}

冰箱{

开门(){}

闭合(){}

}

大象{

进入(冰箱){

}

}

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

类和对象是面向对象的核心概念。

类是对一类事物的描述，是抽象的、概念上的定义

对象是实际存在的该类事物的每个个体，因而也称为实例（instance）

属性：对应类中的成员变量。

行为：对应类中的成员方法

一.设计类

其实就是设计类的成员

属性=成员变量=field=域、字段

方法=成员方法=函数=method

创建类的对象=类的实例化=实例化类

二.类和对象的使用

（面向对象思想落地的实现）

1.创建类、设计类的成员

2.创建类的对象

3.通过“对象.属性”或“对象.方法”调用对象的结构。

三、属性

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

意味着：如果我们修改一个对象的属性a,则不影响另外一个对象属性a的值

四、对象的内存解析

class Person{
    //属性
    String name;
    int age=1;
    boolean isMale;

    //方法
    public void eat(){
        System.out.println("人可以吃饭");
    }

    public void sleep(){
        System.out.println("人可以睡觉");
    }

    public void talk(String language){
        System.out.println("人可以说话，使用的是："+language);
    }
}
//测试类
class PersonTest{
    public static void main(String[] args){
        //创建person类的对象
        Person p1=new Person();
        //Scanner scanner=new Scanner(System.in);

        //调用对象的结构：属性、方法
        //调用属性：“对象.属性”
        p1.name="Tom";
        p1.isMale=true;
        System.out.println(p1.name);

        //调用方法，“对象.方法”
        p1.eat();
        p1.sleep();
        p1.talk("Chinese");

        //***************
        Person p2=new Person();
        System.out.println(p2.name);//null
        System.out.println(p2.isMale);

        //************
        //将p1变量保存的对象地址值赋给p3，导致p1和p3指向了堆空间中的同一个对象实体。
        Person p3=p1;
        System.out.println(p3.name);//Tom

        p3.age=10;
        System.out.println(p1.age);//10
    }
}

 

对象的创建和使用：内存解析

堆：此区域的唯一目的就是存放对象实例，几乎所有的对象实例都在这里分配内存。这一点在Java虚拟机规范中的描述是：所有的对象实例以及数组都要在堆上分配。

通常所说的栈，是指虚拟机栈。虚拟机栈用于存储局部变量等。局部变量表存放了编译期可知长度的各种基本数据类型（Boolean、byte、char、short、int、float、long、double）、对象引用（reference类型，它不等同于对象本身，是对象在堆内存的首地址）。方法执行完，自动释放。

方法区：用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器后的代码等数据。

 

类中属性的使用

属性（成员变量）VS局部变量

1.相同点：

1.1定义变量的格式：数据类型 变量名=变量值

1.2先声明，后使用

1.3变量都有其对应的作用域。

2.不同点：

2.1在类中声明得位置的不同

属性：直接定义在类的一对{}内

局部变量：声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量

2.2关于权限修饰符的不同

属性：可以在声明属性时，指明其权限，使用权限修饰符。

常用的权限修饰符：private、public、缺省、protected  --》封装性

目前，大家声明属性时，都使用缺省就可以了

局部变量：不可以使用权限修饰符

2.3默认初始化值的情况：

属性：类的属性，根据其类型，都有默认初始化值

整型（byte、short、int、long），0

浮点型（float、double） 0.0

字符型（char），0（或'\u0000'）

布尔型（boolean），false

引用数据类型（类、数组、接口）：null

局部变量：没有初始化值。

意味着：我们在调用局部变量之前，一定要赋值。

特别的：形参在调用时，我们赋值即可。

2.4在内存中加载的位置：

属性：加载到堆空间中（非static）

局部变量：加载到栈空间

class UserTest{
    public static void main(String[] args){
        User u1=new User();
        System.out.println(u1.name);
        System.out.println(u1.age);
        System.out.println(u1.isMale);

        u1.talk("日语");
    }
}

class User{
    //属性（或成员变量）
    String name;
    public int age;
    boolean isMale;

    public void talk(String language){//language形参，也是局部变量
        System.out.println("我们使用"+language+"进行交流");
    }
    public void eat(){
        String food="烙饼";//局部变量
        System.out.println("北方人喜欢吃："+food);
    }
}

 

类中方法的声明和使用

方法：描述类具有的功能。

比如：Math类：sqrt()\random()\....

Scanner类：bextXxx()...

Arrays类：sort()\binartSearch()\toString()\equals()\...

1.举例

public void eat(){}

public void sleep(int hour){}

public String getName(){}

public String getNation(String nation){}

2.方法的声明：权限修饰符 返回值类型 方法名(形参列表){

方法体

}

注意：static、final、abstract来修饰的方法

3.说明：

3.1关于权限修饰符，默认方法的权限修饰符都先使用public

Java中的四种权限修饰符：private、public、缺省、protected  -->封装性再细说

3.2返回值类型：有返回值 VS 没有返回值

3.2.1 如果方法有返回值，则必须在方法声明时，指定返回值的类型。同时，方法中，需要使用

return关键字来返回指定类型的变量或数据。"return 数据";

如果方法没有返回值，则方法声明时，使用void来表示。通常没有返回值的方法中，就不需要使用return。但是，如果使用的话，只能"return;"表示结束此方法。

3.2.2我们定义方法的时候该不该有返回值？

①题目要求

②凭经验，具体问题具体分析

3.3方法名：属于标识符，遵循标识符的规则和规范，需要见名知意。

3.4形参列表：方法可以声明0个，1个，或多个形参。

3.4.1格式：数据类型1 形参1，数据类型2，形参2，……

3.4.2我们定义方法时，该不该定义形参

①题目要求

②凭经验，具体问题具体分析

3.5方法体：方法功能的体现。

4.return关键字的使用：

1.适用范围：使用在方法中

2.作用：①结束方法

    ②针对于有返回值类型的方法，使用"return数据"方法，返回所要的数据。

3.注意点：return关键字后面不可以声明执行语句。

5.方法的使用中，可以调用当前类的属性或方法

特殊的：方法A中又调用了A方法

方法中，不可以定义方法。

分类的方法：按照是否有形参及返回值

无返回值

有返回值

无形参

void方法名(){}

返回值的类型 方法名(){}

有形参

void方法名(形参列表){}

返回值的类型 方法名(形参列表){}

class CustomerTest{
    public static void main(String[] args){
        Customer cust1=new Customer();
        cust1.eat();
    }
}

//客户类
class Customer{

    //属性
    String name;
    int age;
    boolean isMale;

    //方法
    public void eat(){
        System.out.println("客户吃饭");
    }

    public void sleep(int hour){
        System.out.println("休息了"+hour+"半个小时");
    }

    public String getName(){
        if(age>18){
            return name;
        }else{
            return "Tom";
        }
    }

    public String getNation(String nation){
        String info="我的国籍是："+nation;
        return info;
    }
}

 

对象数组的题目：

定义类student，包含三个属性：学号number（int），年级state（int），成绩score（int）。创建20个学生对象，学号为1到20，年级和成绩都由随机数确定。

问题一：打印出三年级（state值为3）的学生信息，

问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息

提示

1）生成随机数：Math.random().返回值类型double;

2）四舍五入取整：Math.round(double d),返回值类型long。

class Student {
    int number;//学号
    int state;//年级
    int score;//成绩

    //显示学生信息的方法
    public String info() {
        return "学号" + number + "年级" + state + "成绩" + score;
    }
}




class StudentTest{

    public static void main(String[] args){

        //声明一个student类型的数组
        Student [] stus=new Student[20];
        for(int i=0;i<stus.length;i++){
            //给数组元素赋值
            stus[i]=new Student();
            //给student对象的属性赋值
            stus[i].number=(i+1);
            //年级:[1,6]
            stus[i].state=(int)(Math.random()*(6-1+1)+1);
            //成绩:[0,100]
            stus[i].score=(int)(Math.random()*(100-0+1));

        }

        //遍历学生数组
        for(int i=0;i<stus.length;i++){
            System.out.println(stus[i].info());
        }


        //问题一：打印出三年级（state值为3）的学生信息
        for(int i=0;i<stus.length;i++){
            if(stus[i].state==3){
                System.out.println(stus[i].info());
            }
        }
        //问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息
        for(int i=0;i<stus.length-1;i++){
            for(int j=0;j<stus.length-1-i;j++){
                if(stus[j].score>stus[j+1].score){
                    //如果需要换序，交换的是数组的元素：student对象
                    Student temp=stus[j];
                    stus[j]=stus[j+1];
                    stus[j+1]=temp;
                }
            }
        }

        //遍历学生数组
        for(int i=0;i<stus.length;i++){
            System.out.println(stus[i].info());
        }

        StudentTest test = new StudentTest();
        test.sort(stus);
        test.print(stus);
        test.searchState(stus,1);
    }
    //给student数组排序
    public void sort(Student[] stus) {
        for (int i = 0; i < stus.length - 1; i++) {
            for (int j = 0; j < stus.length - 1 - i; j++) {
                if (stus[j].score > stus[j + 1].score) {
                    //如果需要换序，交换的是数组的元素：student对象
                    Student temp = stus[j];
                    stus[j] = stus[j + 1];
                    stus[j + 1] = temp;
                }
            }
        }
    }
    public void print(Student[] stus){
        for(int i=0;i<stus.length;i++){
            System.out.println(stus[i].info());
        }
    }

    public void searchState(Student[] stus , int state){
        for(int i=0;i<stus.length;i++){
            if(stus[i].state==state){
                System.out.println(stus[i].info());
            }
        }
    }
}

一、理解"万事万物皆对象"

1.在Java语言范畴中，我们都将功能、结构等封装到类中，通过类的实例化，来调用具体的功能结构

>Scanner,String等

>文件:File

>网络资源:URL

2.涉及到Java语言与前端HTML、后端的数据库交互时，前端和后端的结构在Java层面交互时，都体现为类、对象。

二、内存解析说明

1.引用类型的变量，只可能存储两类值：null 或 地址值（含变量的类型）

匿名对象的使用 

1.理解我们创建的对象，没有显示的赋给一个变量名。即为匿名对象

2.特征：匿名对象只能调用一次。

3.使用：

特点：

class Phone{
    double price;
    public void sendEmail(){
        System.out.println("发送邮件");
    }
    public void playGame(){
        System.out.println("玩游戏");
    }
    public void showPrice(){
        System.out.println(price);
    }
}
class PhoneMall{
    public void show(Phone phone){
        phone.sendEmail();
        phone.playGame();
    }
}
class InstanceTest{
    public static void main(String[] args){
        Phone p=new Phone();
        System.out.println(p);
        p.sendEmail();
        p.playGame();
//匿名对象
        new Phone().sendEmail();
        new Phone().playGame();
        new Phone().price=1999;
        new Phone().showPrice();//0.0
        PhoneMall mall=new PhoneMall();
        mall.show(p);
//匿名对象的使用
        mall.show(new Phone());
    }
}

 对比

//非匿名对象

Person p = new Person();

p.name = "蛋蛋";

p.age = 6;

p.height = 1.1;

//匿名对象

new Person.name = "花花";

new Person.age = 21;

new Person.height = 1.2;

UML类图  

this关键字的使用：

1.this可以用来修饰：属性、方法、构造器

2.this修饰属性和方法：

this理解为：当前对象或当前正在创建的对象

2.1在类的方法中，我们可以使用“this.属性”或“this.方法”的方式，调用当前对象属性或方法。但是，通常情况下，我们都选择省略“this.”。特殊情况下，如果方法的形参和类的属性同名时，我们必须显式地使用“this.变量“的方式，表明此变量是属性而非形参。

2.2在类的构造器中，我们可以使用“this.属性”或“this.方法”的方式，调用当前对象属性或方法。但是，通常情况下，我们都选择省略“this.”。特殊情况下，如果构造器的形参和类的属性同名时，我们必须显式地使用“this.变量“的方式，表明此变量是属性，而非形参。

3.this调用构造器。

①我们在类的构造器中，可以显式的使用”this（形参列表）“方式，调用本类中指定的其他构造器

②构造器中不能通过”this（形参列表）“的方式来调用自己。

③如果一个类中有n个构造器，则最多有n-1构造器中使用了”this（形参列表）“

④规定：”this（形参列表）”构造器必须声明在当前构造器的首行

⑤构造器内部，最多只能声明一个“this（形参列表）”，用来调用其他的构造器。

class Person {

    private String name;
    private int age;

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

    public String getName() {
        return name;
    }

    public void setAge(int age) {//当形参和属性重名时，在属性名前面加上this。
        this.age = age;//this表示当前对象的age，后面那个不加this的表示形参
    }

    public int getAge() {
        return age;
    }

    public void eat() {
        System.out.println("人吃饭");
        study();
    }

    public void study() {
        System.out.println("人学习");
    }

    public Person() {
        String info = "阿巴巴巴";
        System.out.println(info);
    }

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

    public Person(int age) {
        this();
        this.age = age;
    }
}
class PersonTest{
    public static void main(String[] args){
        Person p1=new Person();
        p1.setAge(1);
        System.out.println(p1.getAge());
    }
}

 

桜キャンドル淵
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
JAVA面向对象编程入门课程标准.doc
06-28
### JAVA面向对象编程入门课程标准知识点解析 #### 一、课程背景与意义 - **Java语言**: 当前非常流行的网络编程语言之一。 - **面向对象编程(OOP)**: Java的核心特性之一，通过类和对象的概念来组织代码。 - **...
Java - 面向对象的入门
asdasaaasd的博客
03-07 104
Java 类 对象 方法
【Java 2 】Java 类的封装与使用
白骨梦儿
06-26 378
①定义类 ②编写类的成员变量 ③编写类的成员方法 1.3、类的使用 二、类的关键字：private 直接访问类的成员变量是有风险的，因为赋值的类型不一定符号成员变量定义时的变量类型； 所以，在定义class时，可以使用关键字private； private是一个修饰符，可以用来修饰成员（成员变量，成员方法） 三、类的关键字：this this修饰的变量用于指代成员变量，其主要作用是（区分局部变量和成员变量的重名问题） 方法的形参如果与成员变量同名，不带this修饰的变量指的是形参，而不是成员变量 方
java入门基础语法--面向对象（超全超详细）
最新发布
很开心你能来~
05-29 500
java入门基础语法--面向对象
Java面向对象基础
weixin_60719453的博客
10-13 8395
一、前言 我们上次学过java的方法，现在我们来学习新的一篇，也算是java中比较重要的一节了 面向对象基础是java中核心。 面向对象主要包括封装、继承、多态 我们这节主要讲的是封装，在这之前我们先来了解一下类和对象的定义和关系 什么是对象？ 世间一切都是对象，万物解释对象，对象就是看得见摸得着的东西。 什么是类？ 类是现实生活中对具有属性和行为同一类的总称。 类和对象的关系？ 类是对象的抽象化，对象是类的实例化 类的定义 ？ 类是java中的基本概念，java中
Java基础语法（六）| 类和对象
很开心你能来~
03-28 930
Java语法基础 | 类和对象
Java面向对象（适合零基础小白入门教程9）
关注我！带你一路 "狂飙" 到底！
11-20 476
如何定义一个类？方法：就是一段具有独立功能的代码。创建对象，也叫做类的实例化。对象，也叫类的实例。step2：根据类，实例化对象step1：创建类内存分析图内存分析图：构造方法：是一个很特殊的方法。普通方法：一段具有特殊功能的代码。而且可以被多次调用执行。结论：通过反编译工具，发现了一些和源代码不相符的内容，这就是javac编译器，自动给代码中添加的构造方法。用于创建对象。java编译器，发现代码中没有任何的构造方法，在编译时，会自动的帮我们添加一个无参的构造方法。
JAVA面向对象编程入门课程Java面向对象编程上机练习题编程资料标准编程资料
03-24
JAVA面向对象编程入Java面向对象编程上机练习题门课程标准
Java面向对象精髓编程
10-18
学习Java面向对象编程，需要不断地实践和探索。通过编写实际的项目，将理论知识与实际应用相结合，可以更好地理解和掌握这些概念。随着技能的提升，你将能够利用Java的强大功能解决复杂的问题，开发出高效、稳定的...
Java的面向对象编程入门教程by程谱CodeRecipe .zip
10-04
这个入门教程"Java的面向对象编程入门教程by程谱CodeRecipe"将带你深入理解这一概念。 在Java中，面向对象编程（OOP）主要围绕类（Class）、对象（Object）、封装（Encapsulation）、继承（Inheritance）和多态...
从入门到精通：JAVA面向对象编程全攻略
canshanyin的博客
04-28 284
在上面的代码中，我们定义了一个Person类，它有两个成员变量name和age，并使用private关键字进行了封装。封装是面向对象的一个重要原则，它指的是将数据和方法进行组合，形成一个完整的单元，并对数据的访问进行限制。我们创建了三个不同的对象，并分别调用了它们的makeSound()方法，得到了不同的结果。在上面的代码中，我们定义了一个Dog类，它有成员变量name和age，以及一个bark()方法。多态是面向对象的另一个重要特性，它允许不同的对象调用相同的方法，产生不同的结果。
java面向对象基础
05-15
本人面试总结，本人面试总结，本人面试总结，本人面试总结，本人面试总结，本人面试总结，
Java面向对象(OOP)入门
刘程云的博客
11-24 633
强调的是功能行为，面向过程”是一种以过程为中心的编程思想。“面向过程”他们不支持丰富的“面向对象”特性（比如继承、多态），就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了。面向过程在这一系列工作的执行中，强调的是工作的执行。
JAVA基础（笔记）
qq_48385654的博客
08-15 480
q2fefg
Java面象对象编程学习(保姆级教学)
2301_79258776的博客
04-08 989
（易用性差、不是线性安全的）【常见的日期类：LocalData、LocalTime、LocalDataTime-->日期类的实例是不可变的对象，无法直接修改属性值，通常重新实例化】的哈希值：int hashCode()--修改value值：Object setValue(Object value);获取Key值：Object getKey()--获取value值：Object getValue()--返回键值对。向下转型(语法)：<子类型><引用变量>=(<子类型>)<父类引用变量>;
Java 面向对象（基础）
m0_63272315的博客
04-04 1040
1. 面向对象内容的三条主线：- Java类及类的成员：（重点）属性、方法、构造器；（熟悉）代码块、内部类- 面向对象的特征：封装、继承、多态、（抽象）- 其他关键字的使用：this、super、package、import、static、final、interface、abstract等2. 面向过程编程(POP) vs 面向对象编程(OOP)2.1 简单的语言描述二者的区别> 面向过程：- 以`函数`为组织单位。- 是一种“`执行者思维`”，适合解决简单问题。
java——面向对象基础
Wooo_e的博客
02-28 1663
是一种具体步骤的操作，他是微观的。适合解决简单问题，先分析出解决问题的步 骤，然后一步一步的（用函数）去实现即可。c语言就是一个典型的面向过程的语言。结构简单，修改复杂。（程序设计越来越复杂，单纯的面向过程就难以胜任设计程序的需求，现在大多数的语言都是面向对象，c++,C#,java,python....面向对象：是指宏观上分析程序有哪些功能，然后对功能进行分类，把不同的功能封装在不同的类中。他是一种宏观的设计。代码结构：以类为组织单位。每种事物都具备自己的属性和行为/功能。类：具有。
Java面向对象编程---基础篇
技术专家
11-04 597
面向对象介绍 ⚫ 并不是一个技术，而是一种编程指导思想。 ⚫ 把现实世界的具体事物全部看成一个一个的对象来解决实际问题。 为什么要用面向对象编程 ⚫ 生活中我们解决问题就是按照对象化的方式进行的。如果程序也能够按照生活的中的方式来解决问题，那么程序就更符合人类的思维习惯，代码看起来会更易理解、更简单、更易维护。
JavaSE 封装
Mwt258的博客
08-16 95
Java SE封装详解&拓展
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

桜キャンドル淵

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值