一、类与对象

1.面向对象学习的三条主线

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

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

3. 其它关键字：this、super、static、final、abstract、interface、package、import等。“大处着眼，小处着手”。

2.面向对象与面向过程

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

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

举例对比：人把大象装进冰箱。

3.完成一个项目（或功能）的思路

1. 根据问题需要，选择问题所针对的现实世界中的实体。
2. 从实体中寻找解决问题相关的属性和功能，这些属性和功能就形成了概念世界中的类。
3. 把抽象的实体用计算机语言进行述，形成计算机世界中类的定义。即借助某种程序 语言，把类构造成计算机能够识别和处理的数据结构。
4. 将类实例化成计算机世界中的对象。对象是计算机世界中解决问题的最终工具。

4.面向对象中两个重要的概念

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

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

• 面向对象程序设计的重点是类的设计

• 设计类，就是设计类的成员。

二者的关系：对象，是由类new出来的，派生出来的。

5.面向对象思想落地实现的规则一

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

2. 创建类的对象

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

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

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

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

6.对象创建与内存解析

public static void main(String args[]){
    Person p1 = new Person();
    Person p2 = new Person();
    Person p3 = p1;//没有新创建一个对象，共用一个堆空间中的对象实体。

    Persion p1 =new Persion();
    p1.name="Gogo";
    p1.isMale=true;
    Persion p2=new Persion();
    System.out.println(p2.name);//null
    Persion p3 = p1;
    p3.age = 9;
}
class Persion{
    String name;
    int age;
    boolean isMale;
}

【内存解析】

public static void main(String[] args) {
    Student[] stus = new Student[3];
    stus[0] = new Student();
    System.out.println(stus[0].state);//1
    System.out.println(stus[1]);//null
    System.out.println(stus[1].number);//异常
    stus[1] = new Student();
    System.out.println(stus[1].number);//0
}
class Student{
    int number;//学号
    int state;//年级
    int score;//成绩
}

【内存解析】

7.匿名对象

我们创建的对象，没显式的赋给一个变量名。即为匿名对象

特点：匿名对象只能调用一次。

举例：

new Phone().sendEmail();
new Phone().playGame();
new Phone().price = 1999;
new Phone().showPrice();//0.0

应用场景：

PhoneMall mall = new PhoneMall();
//匿名对象的使用
mall.show(new Phone());
//其中，
class PhoneMall{
	public void show(Phone phone){
		phone.sendEmail();
		phone.playGame();
	}
}

8.理解"万事万物皆对象"

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

• Scanner,String等、文件：File、网络资源：URL

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

二、类的结构之一：属性

对比：属性vs局部变量

1.相同点

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

2. 先声明，后使用

3. 变量都其对应的作用域

2.不同点

1. 在类中声明的位置的不同

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

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

2. 关于权限修饰符的不同

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

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

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

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

3. 默认初始化值的情况：

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

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

浮点型（float、double：0.0）

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

布尔型（boolean：false）

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

局部变量：没默认初始化值。

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

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

4. 在内存中加载的位置：

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

局部变量：加载到栈空间

三、类的结构至二：方法

1.方法的声明

权限修饰符 返回值类型 方法名(形参列表){

方法体

}

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

比如：Math类：sqrt()\random() \...
Scanner类：nextXxx() ...
Arrays类：sort() \ binarySearch() \ toString() \ equals() \ ...

举例

public void eat(){}
public void sleep(int hour){}
public String getName(){}
public String getNation(String nation){}

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

Java规定的4种权限修饰符：private、public、缺省、protected

返回值类型： 返回值 vs 没返回值

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

return关键字来返回指定类型的变量或常量：“return 数据”。

如果方法没返回值，则方法声明时，使用void来表示。通常，没返回值的方法中，就不需要

使用return.但是，如果使用的话，只能“return;”表示结束此方法的意思。

我们定义方法该不该返回值？我们定义方法时，该不该定义形参？

1. 题目要求

2. 凭经验：具体问题具体分析

方法名：属于标识符，遵循标识符的规则和规范，“见名知意”

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

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

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

2.方法的重载

定义：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。

总结："两同一不同":同一个类、相同方法名

参数列表不同：参数个数不同，参数类型不同

构成重载的举例

举例一：

Arrays类中重载的sort() / binarySearch()；PrintStream中的println()

举例二：

//如下的4个方法构成了重载
public void getSum(int i,int j){
    System.out.println("1");
}
public void getSum(double d1,double d2){
    System.out.println("2");
}
public void getSum(String s ,int i){
    System.out.println("3");
}
public void getSum(int i,String s){
    System.out.println("4");
}

不构成重载的举例

//如下的3个方法不能与上述4个方法构成重载
//public int getSum(int i,int j){
//    return 0;
//}
//public void getSum(int m,int n){
//
//}
//private void getSum(int i,int j){
//
//}

如何判断是否构成方法的重载？

严格按照定义判断：两同一不同。

跟方法的权限修饰符、返回值类型、形参变量名、方法体都没关系！

如何确定类中某一个方法的调用？

方法名 ---> 参数列表

面试题：方法的重载与重写的区别？

要是这么问，就跟如下的区别一样，说清楚各的作用就行了。

throws\throw

    String\StringBuffer\StringBuilder

    Collection\Collections

    final\finally\finalize

    抽象类、接口


    sleep() / wait()

    ...

3.可变个数形参的方法

这是jdk 5.0新增的内容

可变个数形参的格式：数据类型 ... 变量名

当调用可变个数形参的方法时，传入的参数个数可以是：0个，1个,2个，。。。

• 可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载

• 可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间不构成重载。换句话说，二者不能共存。

• 可变个数形参在方法的形参中，必须声明在末尾

• 可变个数形参在方法的形参中,最多只能声明一个可变形参。

举例

public void show(int i){
}
public void show(String s){
    System.out.println("show(String)");
}
public void show(String ... strs){
    System.out.println("show(String ... strs)");
    for(int i = 0;i < strs.length;i++){
        System.out.println(strs[i]);
    }
}
//不能与上一个方法同时存在
//public void show(String[] strs){
//
//}

调用时：

test.show("hello");
test.show("hello","world");
test.show();
test.show(new String[]{"AA","BB","CC"});

4.递归方法

递归方法：一个方法体内调用它自身。

方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无须循环控制。

递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环。

举例

// 例1：计算1-n之间所自然数的和
public int getSum(int n) {// 3

    if (n == 1) {
        return 1;
    } else {
        return n + getSum(n - 1);
    }

}

// 例2：计算1-n之间所自然数的乘积:n!
public int getSum1(int n) {

    if (n == 1) {
        return 1;
    } else {
        return n * getSum1(n - 1);
    }

}

//例3：已知一个数列：f(0) = 1,f(1) = 4,f(n+2)=2*f(n+1) + f(n),
//其中n是大于0的整数，求f(10)的值。
public int f(int n){
    if(n == 0){
        return 1;
    }else if(n == 1){
        return 4;
    }else{
        //return f(n + 2) - 2 * f(n + 1);
        return 2*f(n - 1) + f(n - 2);
    }
}

//例4：斐波那契数列

//例5：汉诺塔问题

//例6：快排

5+2=2*(5+1)+5

7=17

三、类的结构之三：构造器

构造器（或构造方法）：Constructor

1.构造器的作用

1. 创建对象

2. 初始化对象的信息

2.使用说明

1. 如果没显式的定义类的构造器的话，则系统默认提供一个空参的构造器

2. 定义构造器的格式：权限修饰符 类名(形参列表){}

3. 一个类中定义的多个构造器，彼此构成重载

4. 一旦我们显式的定义了类的构造器之后，系统就不再提供默认的空参构造器

5. 一个类中，至少会有一个构造器。

3.举例

//构造器
public Person(){
    System.out.println("Person().....");
}
public Person(String n){
    name = n;
}
public Person(String n,int a){
    name = n;
    age = a;
}

4.JavaBean概念

所谓JavaBean，是指符合如下标准的Java类：

1. 类是公共的

2. 一个无参的公共的构造器

3. 属性，且对应的get、set方法

5.属性赋值顺序

① 默认初始化

② 显式初始化

③ 构造器中初始化

④ 通过"对象.方法" 或 "对象.属性"的方式，赋值

以上操作的先后顺序：① - ② - ③ - ④

四、关键字package/import/this/return

1. package的使用

1. 为了更好的实现项目中类的管理，提供包的概念

2. 使用package声明类或接口所属的包，声明在源文件的首行

3. 包，属于标识符，遵循标识符的命名规则、规范(xxxyyyzzz)、“见名知意”

4. 每"."一次，就代表一层文件目录。

举例一

某航运软件系统包括：一组域对象、GUI和 Reports 子系统

举例二：MVC 设计模式

模型层：model 主要处理数据

• 数据对象封装：model.bean/domain
• 数据库操作类：model.dao
• 数据库：model.db

控制层：controller 处理业务逻辑

• 应用界面相关：controller.activity

• 存放 fragment：controller.fragment

• 显示列表的适配器：controller.adapter

• 服务相关的：controller.service

• 抽取的基类：controller.base

视图层：view 显示数据

• 相关工具类：view.utils
• 自定义 view：view.ui

JDK中的主要包介绍：

java.lang：包含一些Java语言的核心类，如String、Math、Interger、System和Thread，提供常用功能

java.net：包含执行与网络相关的操作的类和接口。

java.io：包含能提供多种输入、输出功能的类。

java.util：包含一些实用工具类 ，如定义系统特性、接口的集合框架类、使用与日期日历相关的函数 。

java.text：包含了一些java格式化相关的类

java.sql： 包含了Java进行JCDC数据库编程的相关类、接口

java.awt：包含了构成抽象窗口工具集（abstract window toolkits）的多个类，这些类被用来构建和管理应用程序的图形用户界面（GUI）。B/S C/S

2. import的使用

import:导入

1. 在源文件中显式的使用import结构导入指定包下的类、接口

2. 声明在包的声明和类的声明之间

3. 如果需要导入多个结构，则并列写出即可

4. 可以使用"xxx.*"的方式，表示可以导入xxx包下的所结构

5. 如果使用的类或接口是java.lang包下定义的，则可以省略import结构

6. 如果使用的类或接口是本包下定义的，则可以省略import结构

7. 如果在源文件中，使用了不同包下的同名的类，则必须至少一个类需要以全类名的方式显示。

8. 使用"xxx.*"方式表明可以调用xxx包下的所结构。但是如果使用的是xxx子包下的结构，则仍需要显式导入

9. import static:导入指定类或接口中的静态结构:属性或方法。

3.this的使用

可以调用的结构：属性、方法；构造器

this调用属性、方法：

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

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

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

this调用构造器：

1. 我们在类的构造器中，可以显式的使用"this(形参列表)"方式，调用本类中指定的其他构造器

2. 构造器中不能通过"this(形参列表)"方式调用自己

3. 如果一个类中有n个构造器，则最多有 n - 1构造器中使用了"this(形参列表)"

4. 规定："this(形参列表)"必须声明在当前构造器的首行

5. 构造器内部，最多只能声明一个"this(形参列表)"，用来调用其他的构造器

4.return的使用

使用范围：使用在方法体中

作用：

①结束方法

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

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

五、面向对象的特征一 封装性

1.为什么要引入封装性？

面向对象的特征一：封装与隐藏

我们程序设计追求“高内聚，低耦合”。

高内聚 ：类的内部数据操作细节自己完成，不允许外部干涉；

低耦合 ：仅对外暴露少量的方法用于使用。

隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提高系统的可扩展性、可维护性。通俗的说，把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装性的设计思想。

2.问题引入

当我们创建一个类的对象以后，我们可以通过"对象.属性"的方式，对对象的属性进行赋值。

这里，赋值操作要受到属性的数据类型和存储范围的制约。除此之外，没其他制约条件。

但是，在实际问题中，我们往往需要给属性赋值加入额外的限制条件。

这个条件就不能在属性声明时体现，我们只能通过方法进行限制条件的添加。

（比如：setLegs()同时，我们需要避免用户再使用"对象.属性"的方式对属性进行赋值。

则需要将属性声明为私有的(private).

此时，针对于属性就体现了封装性。

3.封装性思想具体的代码体现

体现一：将类的属性xxx私化(private),同时，提供公共的(public)方法来获取(getXxx)和设置(setXxx)此属性的值

private double radius;
public void setRadius(double radius){
	this.radius = radius;
}
public double getRadius(){
	return radius;
}

体现二：不对外暴露的私有的方法

体现三：单例模式（将构造器私有化）

体现四：如果不希望类在包外被调用，可以将类设置为缺省的。

4.Java规定的四种权限修饰符

权限从小到大顺序为：private < 缺省 < protected < public

具体的修饰范围：

4种权限都可以用来修饰类的内部结构：属性、方法、构造器、内部类。

修饰类只能使用：缺省、public

六、JVM内存结构

编译完源程序以后，生成一个或多个字节码文件。

我们使用JVM中的类的加载器和解释器对生成的字节码文件进行解释运行。意味着，需要将字节码文件对应的类加载到内存中，涉及到内存解析。

《jvm规范》

虚拟机栈：即为平时提到的栈结构。我们将局部变量存储在栈结构中。

堆：我们将new出来的结构（比如：数组、对象）加载在堆空间中。

补充：对象的属性（非static的）加载在堆空间中。

方法区：类的加载信息、常量池、静态域。

 

出处：https://www.cnblogs.com/java-blogs/p/15913440.html