JAVA初步学习——第五章类和对象

最新推荐文章于 2024-07-18 16:29:57 发布

Ｓmile____゛定格774

最新推荐文章于 2024-07-18 16:29:57 发布

阅读量126

点赞数

文章标签： java 学习 jvm

本文链接：https://blog.csdn.net/qq_56078818/article/details/126675723

版权

文章目录

一、OOP（编写对象编程）
二、类
三、对象
四、引用（引用类型的变量）
五、方法
六、参数传递
七、this

一、OOP（编写对象编程）

OOP（object oriented programming），面向对象编程

把构成问题的各种事物，抽象成各个对象，这些对象具有解决问题的行为（方法），同时对象还可以具有解决很多类似问题的行为（方法），而不只是能解决一个问题。
面向对象中的对象，泛指现实中一切事物，每种事物都具备自己的属性和行为。面向对象思想就是在计算机程序设计过程中，参照现实中事物，将事物的属性特征、行为特征抽象出来，定义为程序中的一种数据类型。
面向对象的思想，主要强调的是通过调用对象的行为来实现功能，而不是自己一步一步的去操作实现。

封装（Encapsulation）、继承（inheritance）、多态（polymorphism），是面向对象编程中的基本特征，java语言也同样具有这三种特征。

POP（procedure oriented Programming），面向过程编程

分析出，解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，然后依次调用就可以了。

FP（functional programming)，函数式编程

类似于面向过程的程序设计方式，具有很高的抽象程度。JDK8中的一些特性，可以支持使用函数式编程。

二、类

java中对数据类型的描述和定义都是抽象的，每一种数据类型，都是对同一类数据的抽象描述，描述了这种数据的基本特点。

//定了一个 Student 类，这个 Student 类就是一个自定义的数据类型，它本身是对学生的抽象描述
//规定了一个学生数据，应该具有一个 String 类型的name属性
//以及有一个 sayHello 方法。
public class Student{ 
    public String name; 

    public void sayHello(){ } 
}

int 和 String 都不能直接当做具体的数据来使用或者参与运算，因为它们俩个都是对数据的抽象描述，并不能当做具体的数据使用，如果想使用的这些数据的话，可以使用 int 或者 String 类型进行变量的声明，再用变量接收数据，然后就可以使用这个变量来进行操作。

//不能直接使用 Student 类进行操作，因为 Student 类是对学生这种数据的抽象描述
//但是我们可以使用 Student 类声明变量，并且使用这个变量接收一个学生数据（对象）
//然后再使用这个变量对具体的学生数据进行操作（访问属性、调用方法）。
public static void main(String[] args){ 
    //使用Student类，声明变量 
    Student stu; 
   //使用这个变量，接收一个具体的学生数据（也就是对象） 
   stu = new Student(); 
   
   //使用对象访问它的的属性和调用它的方法
   stu.name = "tom"; 
   stu.sayHello(); 
 }

三、对象

我们身边的能看到的东西，都是对象，面向对象的思想中，一切皆为对象。

类和对象的关系：类是一组相关属性和行为的集合，它是对某一种具体事物的抽象描述。
也可以把类看作一个模板，我们使用的对象，就是按照这个模板中的定义，来进行创建的。

类是对一类事物的描述，是抽象的
对象是一类事物的实例，是具体的
类是对象的模板，对象是类的实体

类是一种抽象的数据描述，对象是类的一个具体的实例。

四、引用（引用类型的变量）

引用是可以指向对象的，简称引用指向对象。

使用类创建对象之后，怎么给对象起一个名字，以便后面对这个对象进行操作

//使用new 加上 Student类中构造器，来创建Student类的对象 
new Student(); 

//为了能方便的使用这个对象，就可以给这个对象起一个名字 
//这个过程，其实就是之前学习过的 =号赋值操作 
//把新创建的学生对象，赋值给了引用stu 
Student stu = new Student(); 

//后面就可以使用引用stu来操作对象了，也就是访问对象中的属性和调用对象中的方法 
stu.name = "tom"; 
stu.sayHello();

如果没给对象起名字，这个对象能使用，但是只能在创建这个对象的同时就使用，并且只能使用一次，后面就不能使用了，因为它没有名字，无法在语法上面，表示对这个对象进行使用。

(new Student()).sayHello(); 
//下面就无法再使用上面创建出来的这个对象，因为他没有名字 
... 

//如果再这样写一次，其实是创建了第二个对象，并进行使用，但是后面也无法使用这个对象，因为没有名字 
(new Student()).sayHello();

引用、对象、类之间的关系：
例如，工厂根据电视机图纸（类），生产出了很多台电视机（对象），其中一台电视机卖给了张三，张三坐在沙发上，使用遥控器（引用），可以对这台具体的电视机（对象）进行很方便的操作。

五、方法

方法定义在类中，属于类的成员，所以也可以叫做成员方法。类似的，类中的属性，也可以称为成员变量。

方法定义的格式：

修饰符 返回类型 方法名(参数列表)抛出异常的类型{ 
    //code 
}

修饰符：

public、static、abstract、final等这些都属于修饰符，可以用来修饰方法、属性、类
一个方法上，可以同时拥有多个不同的修饰符，例如程序入口main方法
public static void main(String[] args){...}——这里使用俩个修饰符public和static来修饰main方法
如果方法上有多个修饰符，这些修饰符是没顺序之分的
例如，这俩个写法最终的效果是一样的
- public static void main(String[] args){}
- static public void main(String[] args){}
方法上也可以不写修饰符
void hello(){ //... }

返回类型:

方法执行完，如果有要返回的数据，那么在方法上就一定要声明返回数据的类型是什么，如果没有要返回的数据，那么在方法上就必须使用void进行声明
- public int getNum(){...}
- public void print(){...}
只有一种特殊的方法没有返回类型，也不写void，那就是构造方法，也就是构造器

public class Student{ 
    //构造方法 
    public Student(){} 
}

声明有返回类型的方法，就要使用 return 关键字在方法中，把指定类型的数据返回

public int test(){ 
    return 1; 
}

参数列表：
根据具体情况，可以定义为无参、1个参数、多个参数、可变参数。

public void test(){} 
public void test(int a){} 
public void test(int a,int b,int c){} 
public void test(int... arr){} 
public void test(int a,String str){}

抛出的异常类型：

在方法的参数列表后，可以使用 throws 关键字，表明该方法在将来调用执行的过程中，【可能】会抛出什么类型的异常
可以声明多种类型的异常，因为在方法执行期间，可能会抛出的异常类型不止一种。

区分方法的定义和方法的调用

是方法的定义，方法是没有执行的
如果要执行方法中的代码，那么就一定要去调用这个方法
调用方法的方式为： 对象.方法名()

public class Test{ 
    public void run(){ 
        //这里是需要执行的代码 }
        
        public static void main(String[] args){ 
            Test t = new Test(); 
            t.run();//方法的调用 
        } 
}

六、参数传递

java方法的参数

形参（形式上的参数）：
参数a就是test方法形式上的参数，它的作用就是接收外部传过来的实际参数的值
public void test(int a){}
实参（实际上的参数）：
调用方法的时候，所传的参数1和x，都是test方法实际调用时候所传的参数，简称实参

public class Test{ 
    public void test(int a){} 
}
public static void main(String[] args){ 
    Test t = new Test(); 
    t.test(1); 
    int x = 10; 
    t.test(x); 
}

java参数的传递

值传递：
方法的参数是基本类型，调用方法并传参，这时候进行的是值传递。
值传递，实参把自己存储的值（基本类型都是简单的数字）赋值给形参，之后形参如何操作，对形参一点影响没有。

public class Test{ 
    //该方法中，改变参数当前的值 
    public static void changeNum(int a){ 
        a = 10; 
    }
    public static void main(String[] args){ 
        int a = 1; 
        System.out.println("before: a = "+a);//传参之前，变量a的值 
        changeNum(a); 
        System.out.println("after: a = "+a);//传参之后，变量a的值 
    }
}

引用传递：
方法的参数是引用类型，调用方法并传参，这时候进行的是引用传递。
这时候之所以称之为引用传递，是因为参数和形参都是引用类型变量，其中保存都是对象在堆区中的内存地址。

由于引用传递，是实参将自己存储的对象地址，赋值给了形参，这时候俩个引用（实参和形参）指向了同一个对象，那么任何一个引用（实参或形参）操作对象，例如属性赋值，那么另一个引用（形参或实参）都可以看到这个对象中属性的变量，因为俩个引用指向同一个对象。
这个时候就相当于，俩个遥控器，同时控制同一台电视机。

public class Test{ 
    //该方法中，改变引用s所指向对象的name属性值 
    public static void changeName(Student s){ 
        s.name = "tom"; 
    }
    public static void main(String[] args){ 
        Student s = new Student(); 
        System.out.println("before: name = "+s.name);//传参之前，引用s所指向对象的 name属性值changeName(s);    
        System.out.println("after: name = "+s.name);//传参之后，引用s所指向对象的name 属性值
    } 
}

方法的递归调用
一个方法，在其内部，又调用了自己，这种情况就叫递归。

public int f(int num){ 
    if(num==1){ 
        return 1; 
    }
    return num+f(num-1); 
}

七、this

在类中的非静态方法中，可以使用this关键，来表示当前类将来的一个对象。

this关键字的使用场景：

区别成员变量和局部变量
调用类中的其他方法
调用类中的其他构造器

区别成员变量和局部变量：

public class Student{ 
    public String name; 
    public void setName(String name){ 
        //=号左边的this.name，表示类中的属性name 
       //=号右边的name，表示当前方法的参数name（就近原则） 
       this.name = name; 
    } 
}

调用类中的其他方法：

public class Student{ 
    public String name; 
    public void setName(String name){ 
        this.name = name; 
    }
    public void print(){ 
        //表示调用当前类中的setName方法 
        this.setName("tom"); 
    } 
}

调用类中的其他构造器：

注意，this的这种调用构造器的用法，只能在类中的一个构造器，调用另一个构造器。并且不能在普通的方法中调用类的构造器。
并且要求，this调用构造器的代码，是当前构造器中的第一句代码，否则编译报错。

public class Student{ 
    public String name; 
    public Student(){ 
        //调用一个参数的构造器,参数的类型是String 
        this("tom"); 
    }
    public Student(String name){ 
        this.name = name; 
    } 
}

this关键字的意义：
this代表，所在类的当前对象的引用（地址值），即对象自己的引用。
类中的非静态方法，一定要使用类的对象来进行调用，没有其他的方式！

public class Student{ 
    public void sayHello(){ 
        this.show(); 
    }
    public void show(){ } 
}
public static void main(String[] args){ 
    Student stu1 = new Student(); 
    stu1.sayHello(); //当前执行stu1.sayHello()代码的时候，this代表的就是stu1
    Student stu2 = new Student(); 
    stu2.sayHello(); //当前执行stu2.sayHello()代码的时候，this代表的就是stu2
}