Java类与对象(知识点+练习+扩展)

• 👨‍💻作者简介: 大家好,我是小火车~~,在校大二学生一枚
• 🛳️个人主页: 嘟嘟嘟的小火车的博客
• 📗系列专栏: 本文写在《java从0到1》专栏
• ✉️如果文章知识点有错误的地方,请指正! 和大家一起学习一起进步🎈
• 🔥如果觉得博主的文章还不错的话,请👍三连支持👍一下博主哦

---

一.初识面向对象

1.什么是面向对象？

面向对象是一种符合人类思维习惯的编程思想。现实生活中存在各种形态不同的事物，这些事物之间存在着各种各样的联系。在程序中使用对象来映射现实中的事物，使用对象的关系来描述事物之间的联系，这种思想就是面向对象。

2.面向过程和面向对象的对比

面向过程

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

面向对象

面向对象则是把构成问题的事务按照一定规则划分为多个独立的对象，然后通过调用对象的方法来解决问题。

3.解决问题的思路

对于解决复杂的项目,为了从宏观上把握,从整体上理性分析,我们需要使用面向对象的思路来分析整个项目;但是具体到微观操作,仍然需要面向过程的思路去解决.

4.面向对象编程(OOP)

面向对象编程的本质就是:以类的方式组织代码,以对象的方式组织(封装) 数据

5.Java的3大特性

封装

封装是面向对象的核心思想，将对象的属性和行为封装起来，不需要让外界知道具体实现细节。

继承

继承主要描述的就是类与类之间的关系，通过继承，可以在无需重新编写原有类的情况下，对原有类的功能进行扩展。

多态

多态指的是在一个类中定义的属性和功能被其他类继承后，当把子类对象直接赋值给父类引用变量时，相同引用类型的变量调用同一个方法所呈现出的多种不同行为特性。

二.方法回顾和加深

基础知识点请参考Java方法(知识点+练习+扩展)文章

1.方法的定义

• 修饰符
• 返回值类型
• break和return的区别
• 方法名:注意规范,见名知意
• 参数列表
• 异常抛出

public class Demo01 {
    //main方法,程序一般只有一个main方法
    public static void main(String[] args) {
        
    }
	
    public String sayHello(){
        return "hello,world";
    }
    //返回空 return用来结束方法
    public void hello(){
        return;
    }

    public int max(int a,int b){
        return a>b?a:b;//三元运算符
    }
    //初识异常抛出  后面会详细讲解
    public void readFile(String file) throws IOException{

    }
}

2.方法的调用

• 静态方法

public class Demo01 {
    //main方法,一个项目一般只有一个main方法
    public static void main(String[] args) {
        //静态方法直接可以调用
        String hello = sayHello();
        System.out.println(hello);
    }

    public static String sayHello(){
        return "hello,world";
    }
    
}

• 非静态方法

public class Demo01 {
    //main方法,程序一般只有一个main方法
    public static void main(String[] args) {
        //非静态方法需要先实例一个对象,然后在调用
        Demo01 demo01 = new Demo01();
        String hello = demo01.sayHello();
        System.out.println(hello);
    }

    public String sayHello(){
        return "hello,world";
    }
    
}

• 形参和实参

形式参数和实际参数要对应

• 值传递和引用传递

值传递

基本类型参数的传递,是调用方值的复制.双方各自的修改,互不影响.

简单的来说,方法内部对参数变量的任何操作,都不会影响到方法外部的变量.

public class Demo02 {
    public static void main(String[] args) {
        int a = 1;
        System.out.println(a);//1
        //值传递  把1传递给了形式参数,没有返回值,a还是1
        change(a);
        System.out.println(a);//1
    }

    public static void change(int a){
        a=10;
    }
}

引用传递

引用类型的传递,调用方的变量和接收方的参数变量,地址指向的是同一个对象.双方任意一方对这个变量的修改,都会影响对方.

public class Demo03 {
    public static void main(String[] args) {
        //引用传递
        Person person = new Person();
        //默认为null
        System.out.println(person.name);
        //调用方法改变person对象name属性
        change(person);

        System.out.println(person.name);
    }
    public static void change(Person person){
        person.name = "小火车";
    }
}
class Person{
    String name;
}

三.类与对象

1.类与对象的关系

• 面向对象的编程思想，力图让程序中对事物的描述与该事物在现实中的形态保持一致。为了做到这一点，面向对象的思想中提出了两个概念——类和对象。

• 类是对某一类事物的抽象描述，而对象用于表示现实中该类事物的个体。

• 类用于描述多个对象的共同特征，它是对象的模板，而对象用于描述现实中的个体，它是类的实例。对象是类的具体化，并且一个类可以对应多个对象。

2.类的定义

• 在面向对象的思想中，最核心的就是对象。
• 为了在程序中创建对象，首先需要定义一个类。
• 类是对象的抽象，它用于描述一组对象的共同特征和行为，例如人都有姓名、年龄、性别等特征，还有学习、工作、购物等行为。
• 以面向对象的编程思想，就可以将某一类中共同的特征和行为封装起来，把共同特征作为类的属性（也叫成员变量），把共同行为作为类的方法（也叫成员方法）。

类的定义格式

[修饰符] class 类名 [extends 父类名] [implements 接口名]{

​ // 类体，包括类的成员变量和成员方法

}

声明（定义）成员变量

[修饰符] 数据类型 变量名 [ = 值];

某一个方法中定义的局部变量与成员变量同名，这种情况是允许的，此时方法中通过变量名访问到的是局部变量，而并非成员变量。

声明（定义）成员方法

[修饰符] [返回值类型] 方法名([参数类型 参数名1,参数类型 参数名2,…]){

​ //方法体 …

​ return 返回值; //当方法的返回值类型为void时，return及其返回值可以省略

}

package oop.demo02;
//Students类
public class Students {

    String name;
    int age;
    
    public void study(){
        System.out.println(this.name+"正在学习.");
    }
}

3.对象的创建和使用

• 使用new关键字创建对象

• 使用new关键字创建的时候,除了分配内存空间外,还会给创建好的对象进行默认的初始化以及对类中构造器的调用.

对象创建的语法格式：

类名 对象名称 = new 类名();

package oop.demo02;
//Students类
public class Students {

    String name;
    int age;
    
    public void study(){
        System.out.println(this.name+"正在学习.");
    }
}

package oop.demo02;
public class Application {
    //一个项目应该只存一个main方法
    public static void main(String[] args) {
        //类实例化后会返回一个自己的对象
        Students xm = new Students();
        Students xh = new Students();
        //对象在创建的时候会初始化 name默认值为null age默认值为0
        System.out.println(xm.name);
        System.out.println(xm.age);
        //
        xm.name="小明";
        xm.age=17;
        xh.name="小红";
        xh.age=18;
        System.out.println(xm.name);
        System.out.println(xm.age);
        System.out.println(xh.name);
        System.out.println(xh.age);
    }
}

对象成员的调用:

①通过对象的引用来访问对象所有的成员.

对象引用.对象成员

②直接使用创建的对象本身来引用对象成员.

new 类名().对象成员

对比说明：

第2种方式，创建实例对象的同时就访问了对象成员，并且在创建后只能访问其中某一个成员，而不能像第1种方式那样可以访问多个对象成员。

同时，由于没有对象引用的存在，在完成某一个对象成员的访问后，该对象就会变成垃圾对象。

所以，在实际开发中，创建实例对象时多数会使用对象引用。

成员变量的初始值

成员变量类型	初始值
byte、short、int、long	0
float、double	0.0
char	一个空字符，即’\u0000’
boolean	false
引用数据类型	null，表示变量不引用任何对象

4.访问控制符

在Java中，针对类、成员方法和属性提供了四种访问级别，分别是private、default、protected和public。

四种访问控制级别说明：

• private（当前类访问级别）：如果类的成员被private访问控制符来修饰，则这个成员只能被该类的其他成员访问，其他类无法直接访问。类的良好封装就是通过private关键字来实现的。
• default（包访问级别）：如果一个类或者类的成员不使用任何访问控制符修饰，则称它为默认访问控制级别，这个类或者类的成员只能被本包中的其他类访问。
• protected（子类访问级别）：如果一个类的成员被protected访问控制符修饰，那么这个成员既能被同一包下的其他类访问，也能被不同包下该类的子类访问。
• public（公共访问级别）：这是一个最宽松的访问控制级别，如果一个类或者类的成员被public访问控制符修饰，那么这个类或者类的成员能被所有的类访问，不管访问类与被访问类是否在同一个包中。

访问范围	private	default	protected	public
同一类中	✔️	✔️	✔️	✔️
同一包中		✔️	✔️	✔️
子类中			✔️	✔️
全局范围				✔️

5.构造方法(构造器)

• 类中的构造器也称为构造方法,是在进行创建对象的时候必须要调用的.
• 是类的一个特殊成员，它会在类实例化对象时被自动调用。
• 如果需要在实例化对象的同时就为这个对象的属性进行赋值，可以通过构造方法来实现。

并且构造器有以下两个特点:

• 必须与类的名字相同
• 在方法名的前面没有返回值类型的声明。
• 在方法中不能使用return语句返回一个值，但是可以单独写return语句来作为方法的结束。

定义构造方法的语法格式：

[修饰符] 方法名 ([参数列表]){

​ // 方法体

}

package oop.demo03;

public class Application {
    public static void main(String[] args) {
        //new 实例化了一个对象
        //使用new关键字 本质是在调用构造器
        Person person = new Person();
        System.out.println(person.name);
    }
}
//Person类
package oop.demo03;

public class Person {

    String name;

    public Person(){
        this.name = "小火车";
    }
}

默认的无参构造方法

在Java中的每个类都至少有一个构造方法，如果在一个类中没有显示地定义构造方法，系统会自动为这个类创建一个默认的无参构造方法。

class Person {
    public Person() {
    }    
}

有参构造

package oop.demo03;

public class Application {
    public static void main(String[] args) {
        //new 实例化了一个对象
        //使用new关键字 本质是在调用构造器
        Person person = new Person("嘟嘟嘟的小火车");
        System.out.println(person.name);
    }
}
//Person类
package oop.demo03;

public class Person {

    String name;

    public Person(){
        this.name = "小火车";
    }
    public Person(String name){
        this.name = name;
    }
}

当使用有参构造后,必须把无参构造也打出来,否则没有参数创建对象会报错

6.创建对象内存分析

对象创建的内存分配：

• Java将内存分为两种，即栈内存和堆内存。

• 其中栈内存用于存放基本类型的变量和对象的引用变量（如Person p），堆内存用于存放由new创建的对象和数组。

• 在创建对象时，程序会占用两块内存区域，分别是栈内存和堆内存。

• 其中Person类型的变量p被存放在栈内存中，它是一个引用，会指向真正的对象；通过new Person()创建的对象则放在堆内存中，这才是真正的对象。

---

其他专栏

❤️《编程相关技能》专栏
🧡《HTML5》专栏
💛《CSS3》专栏
💚《java从0到1》专栏
💙《英语语法》专栏