方法（函数、过程）
语法
返回值类型 方法名(参数列表){方法体}
返回值类型：该方法必须返回的一个这个类型的对象
当方法不需要返回值时，返回值类型就定义为void
public static int max(int a,int b){
int max = a>b?a:b;//方法名和变量名不会冲突
//return 返回数据，方法结束
return max;
}void方法中可以写return，但是不能return null
public static void printMax(int a,int b){
//得到最大值
//调用本类中已经定义好的方法
int result = max(a,b);
//打印
System.out.println(result);
return;//仅代表方法结束，终止方法的作用 void方法不能返回包括null的任何值
}参数
形参：定义方法时，参数列表的参数
实参：调用方法时，实际传入的参数
可变参数：
声明：sum(int... a){ }
参数类型跟着三个点表示这种类型的参数可以有很多个
使用：将可变参数当做数组使用
注意点：
1.一个方法中只能有一个可变参数
2.可变参数必须在参数列表的最后一个
3.数量可变，类型不可变
4.调用可变参数方法，可以使用数组代替
5.可变参数可以不传
方法重载
在同一个类中，方法名相同，参数列表不同即为重载
//定义一个方法，返回一个数组的最大值
public static int max(int[] arr){//重载max()
int max = arr[0];
for(int i=0;i<arr.length;i++){
if(arr[i]>max){
max = arr[i];
}
}
return max;
}参数列表不同的要素：
1.参数的类型不同
2.参数的个数不同
3.参数的顺序不同
递归
调用自身
例：阶乘 !99 = 99*98*97*...*1
public static int jiecheng(int num){//阶乘
if(num==1){//递归边界
return 1;
}
return num*jiecheng(num-1);//递归
}排序算法
1.冒泡排序
public static void maopaopaixu(int[] arr){
//比较j趟，最后一个不需要排序
for(int j=0;j<arr.length-1;j++){
//比较一趟，最大值到数组最后
//已经排好的j个元素不需要再重复排序
for(int i=0;i<arr.length-j-1;i++){//数组越界的可能，i+1是最后一个
//前后两个相邻的元素进行比较
//如果前面的元素大，就交换位置
if(arr[i]>arr[i+1]){
int temp = arr[i];
arr[i] = arr[i+1];
arr[i+1] = temp;
}
}
}
}关于其他的排序算法会另外整理：2.选择排序 3.插入排序 4.快速排序...堆排序..桶排序...
面向对象
类
描述对象
声明属性和方法
在类中定义属性，用来存储数据，又叫做全局变量
public class Staff {//员工类：描述员工
String code;//编号
String sex;//性别
String name;//姓名
BigDecimal salary;//薪资 表示金融相关因为浮点型的精度问题要使用大十进制类BigDecimal
//类中的方法可以直接调用本类中的属性
public void work(){
System.out.println(name+"正在工作");
}
}浮点类型在计算机中的存储和计算是有一定精度限制的。由于浮点数使用有限的二进制位数来表示，所以在进行精确的金融计算时可能会出现舍入误差或截断误差。
使用BigDecimal进行金融计算可以确保结果的精度和准确性。它通过将数值存储为字符串或整数数组来表示，并提供了一系列方法来执行加减乘除、取余等常见的数值操作，是处理金融相关计算的一种可靠和推荐的方式。
构造方法：对属性进行初始化
1.构造方法没有返回值类型
2.构造方法的方法名和类名一样
3.如果一个类没有定义任何的构造方法，系统会给予一个默认的空的构造方法
4.类中一旦自定义了任意的构造方法，系统给定的默认的构造方法就消失了
通过构造方法设置属性
局部变量：方法体或代码块中声明的变量
全局变量：在类中声明的变量
就近原则：在同一个代码块中优先找本代码块中的变量
当局部变量和全局变量重名的情况下，可以使用this关键字标注全局变量
Staff(String name){//重载无参构造方法
//将参数name设置给name属性
this.name = name;
}
Staff(String code,String name,String sex,double salary){//重载
this.code = code;
this.name = name;
this.sex = sex;
this.salary = salary;
}对象
实例化对象：用new关键字开辟内存空间
//实例化对象 new开辟内存空间
Staff staff = new Staff();//构造方法，构造器
//设置对象的属性 类中声明了哪些属性，对象中就有哪些属性
staff.code = "YG10001";
staff.name = "王大锤";
staff.sex = "男";
staff.salary = 10000;
//每一个对象都是独立的，都有独立的内存空间，互不影响
Staff staffA = new Staff();
staffA.code = "YG10002";
staffA.name = "赵小芳";
staffA.sex = "女";
staffA.salary = 12000;
//调用对象的方法
staff.work();
staffA.work();关于main方法：运行哪一个类当中的主方法，哪一个类就是主类
面向对象的特征（特性）
封装、继承、多态
1.封装
隐藏细节（属性和方法），不能让其他类随意访问
通过四个访问权限修饰符达到封装的效果
| 修饰符 | public | protected | default | private |
|---|---|---|---|---|
| 含义 | 公共的 | 受保护的 / 家族性的 | 默认的 | 私有的 |
| 访问权限 | 任意 | 子类以及本包下的类 | 本包中 | 本类中 |
| 本类 | 本包下子类 | 其他包的子类 | 本包下的类 | 其他包的类 | |
|---|---|---|---|---|---|
| public | √ | √ | √ | √ | √ |
| protected | √ | √ | √ | √ | × |
| default | √ | √ | × | √ | × |
| private | √ | × | × | × | × |
对私有属性的封装，可以通过 getter 和 setter 方法实现外部的设置和获取
public String getCode() {
return code;
}
public void setCode(String code) {
this.code = code;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}JavaBean 是一种符合特定模式的 Java 类。它是一种可重用的组件，用于构建 Java 应用程序。JavaBean 必须包含无参构造方法，并且可以通过 getter 和 setter 方法访问其属性。它通常用于表示实体类、数据传输对象（DTO）、POJO（Plain Old Java Object）等。JavaBean 是一种轻量级的组件模型，可以通过一些开发工具（如IDE）自动生成代码，使得开发人员可以更快速地创建和使用 JavaBean。
在IDEA工具中，可以通过右键代码 - Generate（或者快捷键Alt+Insert）快捷生成构造方法、getter和setter等
java对大小写敏感
某些情况下可能会通过解析 getName() 方法来得到 name 属性，属性名应小写
2.继承
一个类可以继承父类，子类中就具有父类中定义好的属性和方法
不是所有的属性和方法都能被调用到，public、protected、本包下父类的default
继承的作用：
（1）代码重用
（2）多态实现的基础
注意：
（1）一个子类只能有一个直接父类（单继承）
（2）java支持多重继承（儿子继承父亲，父亲继承爷爷）
继承用关键字 extends
方法重写：子类对父类中继承过来的方法重新定义
可以用 @Override 注解来标识和验证是否是重写的方法
注意：1.重写方法的返回值、方法名、参数列表不能发生变化
2.重写的方法的访问权限只能更开放，不能更闭塞
class Plane{//父类
protected String code;//protected：子类以及本包下的类可以访问到
String color;
public Plane(String code) {
this.code = code;
}
public void fly(){
System.out.println("看，天上有个飞机");
}
}
class BigPlane extends Plane{
//子类继承父类
//子类对父类中继承过来的方法重新定义：方法重写
//可以使用@override注解来验证是否是重写的方法
@Override
public void fly(){
System.out.println("看，天上有个大飞机！！！");
}
}父子类之间的构造方法：
子类的构造方法中首行必须调用父类的构造方法
默认调用父类的无参构造方法
父类中没有无参构造方法时，子类构造方法中必须明文声明调用父类哪一个构造方法
使用 super 关键字调用父类的构造方法
public BigPlane(String code){
super(code);
}
public BigPlane(String code,String color){
//super(code,color);
super(code);
this.color = color;
}向上转型：用父类的指针指向子类的对象
调用方法看对象
调用属性看声明
Plane p =new BigPlane("C919");//向上转型：用父类的指针指向子类的对象
p.code = "BBBBB";//修改父类的属性
BigPlane bp2 = (BigPlane)p;//强转成子类BigPlane类型
bp2.code = "CCCCC";//修改子类的属性
p.fly();//调用子类的方法
p.printcode();假设父类Plane和子类BigPlane各自定义了一个同名属性code，使用父类的指针p指向了子类的对象，此时p调用的方法是子类BigPlane的方法，但p.code修改的是父类Plane的属性。
父类和子类各自定义的属性相互独立存储，不存在冲突
3.多态
调用方法时可能出现多种结果，叫做多态
多态的分类：
静态多态：重载造成，在类编译时就可以确定调用的是哪个方法
动态多态：重写造成，只有在执行到该行代码时，才能确定执行的是哪个类中的方法
public class EasyE {
//简单工厂设计模式，静态static没有工厂对象
public static Parent getObj(int a){
if(a==1){
return new SonA();
}else if(a==2){
return new SonB();
}else {
return new Parent();
}
}
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int num = scanner.nextInt();
Parent p = getObj(num);//p这个变量可能指向任意一个子类的对象
p.method();//多态：调用方法时可能会出现多种结果
}
}
class Parent{
public void method(){
System.out.println("parent");
}
}
class SonA extends Parent{
public void method(){
System.out.println("SonA");
}
}
class SonB extends Parent{
public void method(){
System.out.println("SonB");
}
}