JavaSE-03-Java类和对象

传统的开发方法是面向过程的，面向过程是一种以事件为中心的编程思想。就是分析出解决
问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以
了。
面向过程其实是最为实际的一种思考方式，就是算面向对象的方法也是含有面向过程的思想，
可以说面向过程是一种基础的方法，它考虑的是实际的实现。一般的面向过程是从上往下步步求
精，当程序规模不是很大时，面向过程的方法还会体现出一种优势，因为程序的流程会很清楚。

面向对象(Object-Oriented, 简称 OO) 是一种以事物为中心的编程思想。
对象是真实世界中的事物在人脑中的映象。在实际生活中，我们每时每刻都与“对象”在打
交道，我们用的钢笔，骑的自行车，乘坐的公共汽车等都是对象。这些对象是能看得见、摸得着，
实际存在的东西，我们称之为实体对象；有的对象是针对非具体物体的，但是在逻辑关系上的反
映，比如：钢笔与墨水的关系，人与自行车的关系，我们称之为逻辑对象。

1.2：对象的基本构成

对象同时具备静态的属性和动态的功能。

1.3：Java中的类和对象

1.3.1：Java中的类

把抽象中的实物用Java来表示，这就是Java类；

类是一类事物的抽象表达，类封装了某一类事物的属性和方法，实例化一个类，可以获得该类的一个实例即对象；

类是抽象的概念，仅仅是一个模板；对象是具体的实体；

1.3.2：Java中的对象；

对象是类的实例化，类的实体就是对象；

1.3.3：类和对象的区别；

1：类是虚拟的概念，抽象的概念；类是模子，确定了对象将会拥有什么样的特征（属性）和行为（方法）

2：对象的属性：就是一个对象有什么，是属于他们这一类特定的特征

3：对象的方法：就是能干什么，属于他们这一类的特定的行为；

2：使用一个java类；

2.1：new关键字

假如定义了一个表示日期的类，有三个整数变量；日、月和年的意义即由这些整数变量给出。
如下所示：

class MyDate {
    int day;
    int month;
    int year;
    public String toString() {
        int num=0;
        return day+","+month+","+year;
    }
}

名称 MyDate 按照类声明的大小写约定处理，而不是由语意要求来定。在可以使用变量之前，实际内存必须被分配。这个工作是通过使用关键字 new 来实现的。如下所示：
MyDate myBirth;
myBirth = new MyDate()

第一个语句(声明)仅为引用分配了足够的空间，而第二个语句则通过调用对象的构造方法为构成 MyDate 的三个整数分配了空间。对象的赋值使变量 myBirth 重新正确地引用新的对象。这两个操作被完成后，MyDate 对象的内容则可通过 myBirth 进行访问。

关键字 new 意味着内存的分配和初始化，new 调用的方法就是类的构造方法。

2.2：使用对象和方法

要调用对象中的属性和方法，使用“.”操作符。对象创建以后就有了自己的属性，通过使用“.”操作符实现对其属性的访问。例如：

myBirth.day = 26;
myBirth.month = 7;
myBirth.year = 2000;

对象创建以后，通过使用“.”操作符实现对其方法的调用，方法中的局部变量被分配内存空间，方法执行完毕，局部变量即刻释放内存。例如：

myBirth.toString();

成员变量在堆，局部变量在栈；

3：Java类的组成；

一个完成的Java类由下列六部分组成；

包定义语句
import 语句
类定义{
成员变量
构造方法
成员方法
}

3.1：包

Java语言使用package语句来实现包的定义。package语句必须作为Java源文件的非注释语句第一条语句，指明该文件中定义的类所在的包。若缺省该语句，则指定为无名包，其语法格式为：

package pkg1[.pkg2[.pkg3…]]; //“[]”表示可选
例如：
package org.springframework.boot.autoconfigure.web.servlet;

3.2：import 语句

为了能够使用某一个包的成员，我们需要在 Java 程序中明确导入该包。使用“import”语句可完成此功能。

import package1[.package2…].(classname|*);
例如：
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;

3.3：访问修饰符

Java 语言允许对类中定义的各种属性和方法进行访问控制，即规定不同的保护等级来限制对它们的使用。为什么要这样做？Java 语言引入类似访问控制机制的目的在于实现信息的封装和隐藏。Java 语言为对类中的属性和方法进行有效地访问控制，将它们分为四个等级：private、无修饰符、protected、public，具体规则如下：

public	公有的，可以通过外部访问外部成员
protect	受保护的
	默认的
private	私有的，不可以通过外部访问内部成员

外部访问的方式：

通过类名访问类内部成员：A.a()

通过类的对象来访问类内部成员

在一个类的内部，所有成员都可以相互访问，访问控制符是透明的

3.4：类的定义

Java 程序的基本单位是类，你建立类之后，就可用它来建立许多你需要的对象。Java 把每一个可执行的成分都变成类。

类的定义形式如下：

<权限修饰符> [一般修饰符] class <类名> [extends 父类][implements 接口]{
[<属性定义>]
[<构造方法定义>]
[<方法定义>]
}

3.5：构造方法

什么是构造方法：
类有一个特殊的成员方法叫作构造方法，它的作用是创建对象并初始化成员变量。在创建对象时，会自动调用类无参的构造方法。

构造方法定义规则
Java 中的构造方法必须与该类具有相同的名字，并且没有方法的返回类型（包括没有void ）。另外，构造方法一般都应用 public 类型来说明，这样才能在程序任意的位置创建类的实例－－对象。

如：

public class Rectangle {
    int width;
    int height;
    //这是有参构造方法
    public Rectangle(int w, int h) {
        width = w;
        height = h;
    }
    //无参构造方法
    public Rectangle() {
}

注：每个类至少有一个构造方法。如果不写一个构造方法，Java 编程语言将提供一个默认的，该构造方法没有参数，而且方法体为空。注意：如果一个类中已经定义了构造方法则系统不再提供默认的构造方法。

类在实例化的时候会先执行定义时赋的值，然后再执行构造方法中赋的值；

3.6：成员变量和局部变量

成员变量是指类的一些属性定义，标志类的静态特征，它的基本格式如下：
<权限修饰符> [一般修饰符] 类型 <属性名称> [=初始值]；

3.6.1：定义的区别

成员变量：在类中定义，用来描述对象有什么；

局部变量：在方法中定义，在方法中临时保存数据，方法执行完成就消失了；

3.6.3：作用域区别

成员变量作用在整个类的内部

局部变量作用仅限于定义他的方法中

3.6.4：初始值

成员变量会有一个初始值，但是局部变量没有初始值；

同一方法中不可出现相同的局部变量，但是不同方法中可以出现相同的局部变量名；

3.6.5：存储位置

成员变量存储在堆中，但是局部变量在栈中；

3.7：方法

3.7.1：定义：

方法就是对象所具有的动态功能。Java 类中方法的声明采用以下格式：

<权限修饰符> [修饰符] 返回值类型 <方法名称> (参数列表) [throws 异常列表]{
    [方法体]
}

访问修饰符 ：可以使用四种不同的访问修饰符中的一种，包括 public、 protected、无修饰符和 private。public 访问修饰符表示方法可以从任何其它代码调用。private 表示方法只可以由该类中的其它方法来调用。protected 将在以后的课程中讨论。
修饰符：是对方法特性的描述，例如后面会学习到的：static、final、abstract、synchronized 等等。
返回值类型：表示方法返回值的类型。如果方法不返回任何值，它必须声明为 void(空)。Java 技术对返回值是很严格的，例如，如果声明某方法返回一个 int 值，那么方法必须从所有可能的返回路径中返回一个 int 值（只能在等待返回该 int 值的上下文中被调用。）
方法名称：可以是任何合法标识符，并带有用已经使用的名称为基础的某些限制条件。
参数列表：允许将参数值传递到方法中。列举的元素由逗号分开，而每一个元素包含一个类型和一个标识符。在下面的方法中只有一个形式参数，用 int 类型和标识符 days 来声明：public void test(int days){}
throws 异常列表：子句导致一个运行时错误（异常）被报告到调用的方法中，以便以合适的方式处理它。异常在后面的课程中介绍。花括号内是方法体，即方法的具体语句序列。

3.7.2:形参和实参

对于方法的参数的理解，分为形参和实参：
形参：就是形式参数的意思。是在定义方法的时候使用的参数，用来标识方法接收的参数类型，在调用该方法时传入。
实参：就是实际参数的意思。是在调用方法时传递给该方法的实际参数。

形参和实参的类型必须要一致，或者要符合隐含转换规则

形参类型不是引用类型时，在调用该方法时，是 按值传递的。在该方法运行时，形参和实参是不同的变量，它们在内存中位于不同的位置，形参将实参的值复制一份，在该方法运行结束的时候形参被释放，而实参内容不会改变。
形参类型是引用类型时，在调用该方法时，是 按引用传递的。运行时，传给方法的是实参的地址，在方法体内部使用的也是实参的地址，即使用的就是实参本身对应的内存空间。所以在函数体内部可以改变实参的值。

4：this关键字

4.1：点取属性

this.day 指的是调用当前对象的 day 字段，

public class TestMain {
    private int day, month, year;

    public void tomorrow() {
        this.day = this.day + 1;
    // 其他代码
    }

}

“this.变量“调用的是当前属性的变量值，直接使用变量名称调用的是相对距离最近的变量的值。

4.2：调用类中其他的方法；

public class TestMain {
    public void t() {
        this.t2();
    }
    public void t2() {
        System.out.println("t2 方法");
    }

}

4.3：作为方法名来初始化对象

this 用在构造方法中，this()也就是相当于调用本类的其它构造方法，它必须作为构造方法的第一句。示例如下：

public class Test {
    public Test() {
        this(3);// 在这里调用本类的另外的构造方法
    }
    public Test(int a) {
    }
    public static void main(String[] args) {
        Test t = new Test();
    }
}

5：引用类型

5.1：什么是引用类型

引用类型（reference type）指向一个对象，不是原始值，指向对象的变量是引用变量。

在 Java 里面除去基本数据类型的其它类型都是引用数据类型，自己定义的 class 类都是引用类型，可以像基本类型一样使用。在 Java 程序运行时，会为引用类型分配一定量的存储空间并解释该存储空间的内容。

public class MyDate {
    private int day = 8;
    private int month = 8;
    private int year = 2008;
    public MyDate(int day, int month, int year){…}
    public void print(){…}
}
public class TestMyDate {
    public static void main(String args[]) {
        // 这个 today 变量就是一个引用类型的变量
        MyDate today = new MyDate(23, 7, 2008);
    }
}

5.2：引用类型赋值

在 Java 编程语言中，用类的一个类型声明的变量被指定为引用类型，这是因为它正在引用一个非原始类型，这对赋值具有重要的意义。请看下列代码片段：

int x = 7;
int y = x;
String s = "Hello";
String t = s;

四个变量被创建：两个原始类型 int 和两个引用类型 String。x 的值是 7，而这个值被复制到 y；x 和 y 是两个独立的变量且其中任何一个的进一步的变化都不对另外一个构成影响。至于变量 s 和 t，只有一个 String 对象存在,它包含了文本“Hello”，s 和 t 均引用这个单一的对象。

将变量 t重新定义为：t=”World”; 则新的对象 World 被创建，而t引用这个对象。上述过程被描述如下：

5.3：按值传递和按引用传递

5.3.1：按值传递

指的是在方法调用时，传递的参数是按值的拷贝传递。示例如下：

1. public class TempTest {
2.     private void test1(int a) {
3.         // 做点事情
4.         a++;
5.     }
6.     public static void main(String[] args) {
7.         TempTest t = new TempTest();
8.         int a = 3;
9.         t.test1(a);// 这里传递的参数a就是按值传递。
10.         System.out.println("main方法中的a===" + a);
11.     }
12. }

按值传递重要特点：传递的是值的拷贝，也就是说传递后就互不相关了。第 9 行的 a 和第 2行的 a 是两个变量，当改变第 2 行 a 的值，第 9 行 a 的值是不变的，所以打印结果是 3。

5.3.2：按引用传递

指的是在方法调用时，传递的参数是按引用进行传递，其实传递的引用的地址，也就是变量所对应的内存空间的地址。示例如下：

1. public class TempTest {
2.     private void test1(A a) {
3.         a.age = 20;
4.         System.out.println("test1 方法中的age="+a.age);
5.     }
6.     public static void main(String[] args) {
7.         TempTest t = new TempTest();
8.         A a = new A();
9.         a.age = 10;
10.         t.test1(a); // 这里传递的参数a就是按引用传递
11.         System.out.println("main方法中的age="+a.age);
12.     }
13. }
14.     class A {
15.         public int age = 0;
16.     }

运行结果如下： test1 方法中的 age=20 main 方法中的 age=20

按引用传递的重要特点：
传递的是值的引用，也就是说传递前和传递后都指向同一个引用（也就是同一个内存空间）。

总结，按引用传递传递的是传递的是一个内存的地址的引用；如果直接操作这个地址，那么该内存地址的数据就会发生改变；

如果将该引用又指向别的地址，那么在修改他，就不会影响之前的数据

6：类中的变量

6.1：实例变量与局部变量

在方法外定义的变量主要是实例变量，它们是在使用 new Xxxx ()创建一个对象时被分配内存空间的。每当创建一个对象时，系统就为该类的所有实例变量分配存储空间；创建多个对象就有多份实例变量。通过对象的引用就可以访问实例变量。

在方法内定义的变量或方法的参数被称为局部 (local) 变量，有时也被用为自动（automatic）、临时（temporary）或栈stack）变量。

方法参数变量定义在一个方法调用中传送的自变量，每次当方法被调用时，一个新的变量就被创建并且一直存在到程序的运行跳离了该方法。当执行进入一个方法遇到局部变量的声明语句时，局部变量被创建，当执行离开该方法时，局部变量被取消，也就是该方法结束时局部变量的生命周期也就结束了。

6.2：实例变量的初始化

在 Java 程序中，任何变量都必须经初始化后才能被使用。当一个对象被创建时，实例变量在分配内存空间时按程序员指定的初始化值赋值，否则系统将按下列默认值进行初始化：

数据类型	初始值
byte	0
short	0
int	0
long	0L
char	'\u0000'
float	0.0F
double	0.0D
boolean	false
引用类型	null

注意：一个具有空值“null”的引用不引用任何对象。试图使用它引用的对象将会引起一个异常。异常是出现在运行时的错误，这将在模块“异常”中讨论。

7：java类的基本执行顺序

程序入口main - 初始化对象 - 初始该对象的属性 - 构造方法 ----

苍煜

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
JavaSE-03-Java类和对象

1：理解面向对象1.1：为什么要面向对象传统的开发方法是面向过程的，面向过程是一种以事件为中心的编程思想。就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了。面向过程其实是最为实际的一种思考方式，就是算面向对象的方法也是含有面向过程的思想，可以说面向过程是一种基础的方法，它考虑的是实际的实现。一般的面向过程是从上往下步步求精，当程序规模不是很大时，面向过程的方法还会体现出一种优势，因为程序的流程会很清楚。面向对象(Object-Orie
复制链接

扫一扫