1.面向对象程序设计(OOP)
1.概述
1.类
类(class)指定了如何构造对象。由一个类构造对象的过程称为创建这个类的一个实例。
类是抽象的、概念的，代表一类事务，就是数据类型
对象是具体的，实际的，代表一个具体事务，就是类的一个具体实例。
类是对象的模板，对象是类的一个个体，对应一个实例。
2.实例字段和方法
对象中的数据称为实例字段，操作数据的过程称为方法。
作为一个类的实例，一个特定的对象有一组特定的实例字段。
这些值的集合就是这个对象的当前状态。只要对象上调用一个方法，他的状态就有可能发生改变。
3.封装
封装（有时称为信息隐藏）是处理对象的一个重要概念。
从形式上看，封装就是将数据和行为组合在一个包中，并对对象的使用者隐藏具体细节的实现细节。
封装的关键在于，绝对不能让其他类中的方法直接访问这个类的实例字段。程序只能通过对象的方法与对象数据进行交互。封装为对象赋予了“黑盒”的特征，这是提高重用性和可靠性的关键。
4.继承
可以通过扩展其他类来构建新类。扩展一个已有的类时，这个新类具有被扩展的那个类的全部属性和方法。你只需要在新类中提供适用于这个新类的新方法和实例字段。
通过扩展一个类来得到另外一个类的概念称为重载
5.对象
对象的三个特性是使用OOP的前提：
- 对象的行为 ———— 可以对这个方法做哪些操作，或者可以对整个对象应用那些方法？
- 对象的状态 ———— 调用方法时，对象会如何响应？
- 对象的标识 ———— 如何区分可能有相同行为和状态的不同对象？
同一个类的所有实例对象都有一种家族相似性，他们都支持像相同的行为。一个对象的行为由所能调用的方法来定义。
对象的状态：每个对象都会保存着描述当前状况的信息。
对象的状态可能随着时间而发生改变，但这种改变不是自发的。对象状态的改变必然是调用方法的结果。（如果不经过方法调用就可以改变对象状态，这说明破坏了封装性）
对象的状态并不能完全描述一个对象，因为每个对象都有一个唯一的标识（或称身份）
例如在一个订单处理系统中，就算商品一致，也是不同订单。 作为同一个类的实例，每个对象的标识总是不同的，状态也通常有所不同。
2.类和对象
1.对象在内存中存在形式
2.属性/成员变量
1.从概念或叫法上看：成员变量 = 属性 = filed（字段） （即成员变量是用来表示属性的）
2.属性是类的一个组成部分，一般是基本数据类型，也可以是引用类型（对象，数组）
3.属性定义同语法变量：访问修饰符 属性类型 属性名;
属性的定义类型可以为任意类型，包含基本类型或引用类型
属性如果不赋值，有默认值，规则和数组一致
3.创建对象
先声明在创建
类名 对象名 = new(构造符) 类名();
直接创建
类名 对象名 = new(构造符) 类名()
4.类和对象的内存分配机制
当对象指向的地址为null时（例如arr2=null），在访问对象类内元素就会抛出异常
Java内存的结构分析
1.栈：一般存放基本数据类型（局部变量）
2.堆：存放对象（对象，数组等）
3.方法区：常量池（常量，比如字符串），类加载信息
Java创建对象的流程简单分析
Person p =new Person(); p.name = "jack"; p.age = 10;
- 先加载Person类信息（属性和方法信息，只会加载一次）
- 在堆中分配空间，进行默认初始化（按照默认规则）
- 将地址赋给对象p，p就指向对象
- 进行指定初始化，例如 p.name="jack" p.age=10
5.类和类之间的关系
类之间最常见的关系有：依赖、聚合、继承
依赖，即“use-a”关系，是一种最明显也是最一般的关系。 如果一个类的方法要使用或操作另一个类的对象，我们就说前一个类依赖于后一个类。
应当减少相互依赖的类。 如果类A不知道类B的存在，类B的改变就不会影响到类A（这意味着B的改变不会在A中引入bug）。 减少相互依赖的类，就是尽可能减少类之间的耦合
聚合，即“has-a”关系。包含关系意味着类A的对象包含类B的对象
继承，即“is-a”，表示一个更特殊的类与一个更一般的类之间的关系。一般而言，如果D类扩展了C类，D类会继承C类的方法，另外还会有一些额外的功能。
3.方法
1.方法的调用机制
Person p1 = new Person();
int returnRes = p1.getSum(10,20);
System.out.println("getSum方法返回的值=");
pubilc int getSum(int num1,int num2){
int res = num1 + num2;
return res;
}
1.当程序执行到方法时，就会开辟一个独立的空间（栈空间）
2.当方法执行完毕或执行到return语句时，就会返回，此时该栈空间自动销毁
3.返回的位置为调用方法的地方，返回后继续执行后面的代码
2.成员方法的好处
1.提高代码的复用性
2.可以将代码实现的细节封装起来，供其他用户调用
3.成员方法的定义
访问修饰符 返回数据类型 方法名 (参数列表...){//方法体
语句;
return 返回值;
}
1.参数列表：表示成员方法输入
2.返回数据类型：表示成员方法的输出，void 表示没有返回值
3.方法主体：表示为了实现某一功能代码块
4.return 语句不是必须的
4.返回类型和修饰符的注意事项和使用细节
1.Java 的修饰符一般分为两类：访问修饰符、非访问修饰符
2.修饰符用来定义类、方法或者变量，通常放在语句的最前端
3.Java中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限。
-
default (即默认，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。
-
private : 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类）
-
public : 对所有类可见。使用对象：类、接口、变量、方法
-
protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）。
4.返回类型可以为任何类型，包含基本类型或引用类型
5.一个方法最多有一个返回值，可以使用引用类型（数组、对象）返回多个结果
6.如果方法要求有返回数据类型，则方法体重最后的执行语句必须为return值。 而却要求返回类型必须和return的值类型一致或兼容（可以自动转换）
7. 如果方法要求返回void，则方法体中可以没有return语句或只写return
5.形参列表和方法体的注意事项和使用细节
1.一个方法可以有0个参数，也可以有多个参数，中间用逗号隔开
2.参数类型可以为任意类型，包含基本类型或引用类型
3.调用带参数的方法时，一定要对应参数列表传入相同类型或兼容类型的参数
4.方法定义时的参数称为形式参数，简称形参；方法调用时的传入参数称为实际参数，简称实参
实参和形参的类型要一致或兼容、个数、顺序必须一致
5.方法体里写功能的具体语句，如输入输出、变量、运算、分支、循环、方法调用
6.方法不能嵌套定义。即方法里面不能再定义方法
6.方法的调用
1.同一个类中的方法调用：直接调用
同类调用，不需要创建对象，直接调用即可
2.跨类中顶点方法调用，A类调用B类方法：需要通过对象名调用（对象名.方法名）
跨类调用，先创建对象，再通过对象名调用
PS：注意在A类中，需要先创建B类对象，再进行调用
7.方法的传参机制
1.基本数据类型，传递的是值（值拷贝而非地址），形参的任何改变都不影响实参
public class test {
public static void main(String[] args)
{
int a = 10;
int b = 20;
AA obj = new AA();
obj.swap(a,b);
System.out.println("main方法 a=" + a + " b=" + b);
}
}
class A{
public void swap(int a,int b)
{
System.out.println("\na和b交换前的值\na=" + a + "\tb=" + b);
int tmp = a;
a = b;
b = tmp;
System.out.println("\na和b交换后的值\na=" + a + "\tb=" + b);
}
}
2.引用类型传递的是地址（传递的也是值，但值是地址），可以通过形参影响实参
在引用类型的地址中，形参和实参共用一个堆中的对象空间
public class test {
public static void main(String[] args)
{
Person p = new Person();
p.name = "Jack";
p.age = 10;
B b =new B();
b.test200(p);
System.out.println("main 的p.age=" + p.age);
}
}
class Person{
String name;
int age;
}
class B
{
public void test200(Person p){
p.age = 10000;//修改属性
}
}
类中方法参数指向null时
public class test {
public static void main(String[] args)
{
Person p = new Person();
p.name = "Jack";
p.age = 10;
B b =new B();
b.test200(p);
System.out.println("main 的p.age=" + p.age);
}
}
class Person{
String name;
int age;
}
class B
{
public void test200(Person p){
p = null;//修改属性
}
}
5.递归
1.执行一个方法时，就创建一个新的受保护的独立空间（栈空间）
2.方法的局部变量是独立的，不会相互影响
3.如果方法中使用的是引用类型变量（比如数组），就会共享该引用类型的数据
4.递归必须向退出递归的条件逼近，否则就是无限递归，出现Stack Overflow Error
5.当一个方法执行完毕，或者遇到return，就会返回，遵守谁调用，就将结果返回给谁，同时当方法执行完毕或者返回时，该方法也就执行完毕
6.重载
1.注意细节
- 方法名：必须相同
- 参数列表：必须不同（参数类型或个数或顺序，至少有一样不同，参数名无要求）
- 返回类型：无要求
7.可变参数
1.基本概念语法
1.Java语法允许将同一个类中多个同名同功能但参数个数不同的方法，封装成一个方法
2.基本语法：
访问修饰符 返回类型 方法名(数据类型... 形参名){
}
2.注意细节
1.可变参数的实参可以为0个或任意多个
2.可变参数的实参可以为数组
3.可变参数的本质就是数组
4.可变参数可以和普通类型的参数一起放在形参列表，但必须保证可变参数在最后
5.一个形参列表中只能出现一个可变参数
8.作用域
1.基本使用
1.在Java中，主要变量就是属性（成员变量）和局部变量
2.全局变量作用域：整个类体
局部变量：定义他的代码块中
3.全集变量可以不赋值直接使用，因为有默认值
局部变量必须赋值后，才能使用，因为没有默认值
2.注意细节
1.属性和局部变量可以重名，访问时遵循就近原则
2.在同一个作用域中，比如在同一个成员方法中，两个局部变量不能重名
3.属性声明周期较长，伴随着对象的创建而创建，伴随着对象的死亡而死亡。
局部变量声明周期较短，伴随它的代码块的执行而创建，伴随代码块的结束而销毁。即在一次方法调用过程中生效。
4.作用域范围不同
全局变量/属性：可以被本类使用，或者其他类使用（通过对象调用）
局部变量：只能在本类中对应的方法中使用
5.修饰符不同
全局变量/属性可以加修饰符
局部变量不可以加修饰符
9.构造器
1.构造器定义
构造方法又叫构造器，是类的一种特殊的方法，他的主要作用是完成对新对象的初始化
基本语法：
[修饰符] 方法名 (形参列表){
方法体;
}
1.构造器的修饰符为：默认、public、protected、private
2.构造器没有返回值，也没有返回类型（不允许写void）
3.构造起的方法名和类名必须一样
4.参数列表规则与成员方法相同
5.构造器的调用，由系统完成。在创建对象时，系统会自动的调用该类的构造器完成对对象的初始化
2.构造器的细节
1.一个类可以定义多个不同的构造器，即构造器重载
2.构造器是完成对象的初始化，并不是创建对象
3.在创建对象时，系统自动的调用该类的构造方法
4.如果程序员没有定义构造器，系统会自动给类生成一个默认无参构造器（默认构造器）
5.一旦定义了自己的构造器，默认构造器就被覆盖了，就无法再使用默认的无参构造器，除非显式的定义一下
10.this关键字
Java虚拟机会给每个对象分配this，代表当前对象。
1.this关键字可以用来访问本类的属性、方法、构造器
2.this用于区分当前类的属性和局部变量
3.访问成员方法的语：this.方法名(参数列表);
4.访问构造器语法：this(参数列表); 注意只能在构造器中使用
只能在构造器中访问另一个构造器，且必须放在第一条语句
5.this不能在类定义的外部使用，只能在类定义的方法中使用
11.包
1.包的定义
1.包的作用：
区分同名的类
当类很多时，可以很好的管理类
控制访问范围
2.包的基本语法：
package 包名; //package 关键字，表示打包
2.包的细节
1.包的本质，就是创建不同的文件夹来保存类文件
2.包的命名规则：只能包含数字、字母、下划线、小圆点，但不能用数字开头，不是关键字或保留字
3.包的命名规范：一般是小写字母+小圆点 —> com.公司名.项目名.业务模块名
4.常用的包：
- java.lang.* //lang包是基本包，默认引入，不需要再引入
- java.util.* //util包，系统提供的工具包，工具类，使用Scanner
- java.net.* //网络包，网络开发
- java.awt.* //java的界面开发，GUI
5.包的引入
import 包;
使用 包.* 代表引入该包的所有类
使用 包.类名 代表引入该包的当前类
6. package 的作用是声明当前类所在的包，需要放在类的最上面，一个类中最多只有一句package（也可以不为该类打包）
import指令 位置放在package的下面，在类定义前面，可以有多句且没有顺序要求
12.访问修饰符
java提供四种访问控制修饰符号，用于控制方法和属性（成员变量）的访问权限（范围）：
1.公开级别：public 修饰，对外公开
2.受保护级别：protected 修饰，对子类和同一个包中的类公开
3.默认级别：没有修饰符号，向同一个包的类公开
4.私有级别：private 修饰，只有类本身可以访问，不对外公开
| 访问级别 | 访问控制修饰符 | 同类 | 同包 | 子类 | 不同包 |
| 公开 | public | √ | √ | √ | √ |
| 受保护 | protected | √ | √ | √ | × |
| 默认 | 无修饰符 | √ | √ | × | × |
| 私有 | private | √ | × | × | × |
1.修饰符可以用来修饰类中的属性，成员方法以及类
2.只有默认的和public才能修饰类，并且遵循上述访问权限的特点
3.成员方法的访问规则和属性完全一样
标签：调用,JAVA,对象,修饰符,构造,参数,程序设计,方法 From： https://www.cnblogs.com/yzr-zy/p/17677416.html