注：类、继承、多态等内容量大且联系紧密，会掺杂我个人理解，如果内容错误欢迎评论区留言。
方法（函数）
一个过程
语法定义
返回值类型 方法名(参数列表){方法体}，例：int max(int a,int b){ return a>b?a:b; }
返回值类型 该方法必须返回一个该类型的对象
参数 ：实参和形参
形参：定义方法时参数列表的参数名int max(int a,int b)
实参：调用方法时实际传入的参数,例:max(a,b)
方法调用
public void printMaxA(int a,int b) {
int max=max(a,b);
System.out.println(max);
return;//终止方法的作用
}
//这是一个实例方法，在其他类中实例方法必须通过类的实例来调用。
//实例方法属于类的实例，可以访问实例变量和静态变量。
//例如：object.sum(1, 2)，其中object是该类的一个实例。
public int sum(int a,int b) {
return a+b;
}
//void 当一个方法不需要返回值 返回值类型就定义为void
//void 不能return null;
//void 可以写return;只代表方法结束
public static void printMax(int a,int b) {
System.out.println(a>b?a:b);
return;//终止方法的作用
}
方法重载
//同一个类中方法名相同，参数数量、类型和类型的顺序不同(参数列表不同)即为重载
public int sum(int a,int b,int c) {
return a+b+c;
}
public int sum(byte a,int b) {
return a+b;
}
public int sum(int a,byte b) {
return a+b;
}
可变参数
//可变参数 在参数列表的最后一个位置定义(使用...)
//声明 numsSum(int...arr) {}
//使用 将可变参数当作数组使用
//调用 numsSum(1,2,3,4,5);
public static int numsSum(int...arr) {
int sum=0;
for(int num:arr) {
sum+=num;
}
return sum;
}
//注意事项
//1.一个方法只能有一个可变参数
//2.可变参数必须在列表最后一个numsSum(int a,int b,int...arr)
//3.调用传参时数量可变类型不可变
//4.调用可变参数方法可以使用数组代替
//5.可变参数可以不传
递归
方法调用自身的过程
三要素：递归定义、递归出口、递归调用
//递归
//正数阶乘
public long jiecheng(long num) {
if(num<=0)return 0;//0和负数返回0表示错误
if(num==1)return 1;
return num*jiecheng(num-1);
}
类
public class Staff {
//在类中定义属性
//全局变量
String code;
String sex;
String name;
//表示金融的不能用浮点型,浮点型是算出来的
//BigDecimal salary;
double salary;//此处是例子所以简化
//方法
//类中声明的方法可以直接调用类中的属性
//方法名可以和类名一样
public void work() {
System.out.println(name+"正在工作。");
}
//构造方法
//构造方法没有返回值类型 （区别：void是没有返回值）
//方法名和类名一样
//如果一个类没有定义任何构造方法，系统会给予一个默认的空的无参构造方法
//类中一旦自定义了任意构造方法，系统给定的构造方法就没有了
//无参构造方法（一般没有写构造方法系统自动生成）
public Staff() {}
//所有类都是Object的子类
public Staff(String code, String name, String sex, double salary) {
super();//调用父类无参构造方法构造父类
//就近原则，如果写name=name代码会优先找参数(局部变量)
//局部变量 方法体或者代码块中声明的变量
//全局变量 类中定义的变量
//在局部变量和全局变量重名的情况下可以使用this关键字标注全局变量
this.code = code;
//如果父类也有code，想在子类调用要super.code,前提是父类设置code不是私有变量
this.name = name;
this.sex = sex;
this.salary = salary;
}
}
面向对象
特性：封装、继承、多态 （抽象并不是）
封装
//封装 隐藏细节 不让其他类随意的访问
//实现封装：通过四个访问权限修饰符达到封装的效果
//public protected default（默认） private
//public 公共的 所有类都可以访问
//protected 本包下的类 和本包或不同包子类均可访问
//defualt(不用明文写出，会报错，系统默认) 本包下可以访问
//private 只能在本类访问
//经典方法：getter setter javabean
private String name;//java对大小写敏感故变量名Name是get和set方法易出现错误
public String getName() {return this.name;}
public void setName(String name) {this.name=name;}
继承
一个类继承父类，这个类就是子类，子类具有父类中定义好的属性和方法
//好处：
//1.实现了代码重用
//2.多态实现的一个基础
//注意：不是所有的属性和方法都能访问到 public protected defualt(本包下的父类)
//一个类只能继承一个父类，一个父类可以有多个子类
//java支持多重继承 继承 继承继承的继承 ...
举例说明：
package com.easy;
public class EasyG {
//继承 一个类继承父类，这个类就是子类，子类具有父类中定义好的属性和方法
//好处：
//1.实现了代码重用
//2.多态实现的一个基础
//注意：不是所有的属性和方法都能访问到 public protected defualt(本包下的父类)
//一个类只能继承一个父类，一个父类可以有多个子类
//java支持多重继承 继承 继承继承的继承 ...
public static void main(String[] args) {
BigPlane bp=new BigPlane();
bp.code="9527";
bp.fly();
//向上转型 父类的指针指向子类的对象
Plane p=new BigPlane();
//调用方法看对象 调用属性看声明
//只能调用父类的方法和子类中重写的方法 访问属性都是父类的
p.fly();//调用子类的方法
System.out.println(p.color);//白
}
}
class Plane{
String code;
String color="白";
public Plane() {
super();
}
public Plane(String code, String color) {
super();
this.code = code;
this.color = color;
}
public void fly() {
System.out.println("飞，牢大要坠机喽");
}
}
//子类继承父类
class BigPlane extends Plane{
//方法重写
//子类对父类继承过来的方法重新定义
//注意
//只重新定义方法体，参数列表和返回类型不能重写
//使用注解@Override验证方法是否重写的方法
//重写设置权限只能是更开放的
//子父类间的构造方法
String color="黑";//可以定义，但和父类是独立的
public BigPlane() {
super();
}
public BigPlane(String code, String color, String color2) {
//子类构造方法中首行必须先调用父类的构造方法
//默认调用父类的无参构造方法
//父类没有无参构造方法，子类构造方法中必须明文声明调用父类哪一个构造方法
//使用super关键字调用父类构造方法
super(code, color);
color = color2;
}
@Override
public void fly() {
System.out.println("飞，牢大永不坠机");
}
}//方法重写
子类对父类继承过来的方法重新定义
//注意
//只重新定义方法体，参数列表和返回类型不能重写
//使用注解@Override验证方法是否重写的方法
//重写设置权限只能是更开放的
多态
调用方法时可能会出现多种结果
//多态分类：
//静态多态：由重载造成，在类编译（javac）时就可以确定执行的是哪一个方法
//动态多态：由重写造成，只有在执行到该行代码才能确定执行的是哪一个类的方法
package com.easy;
public class EasyEE {
public static void main(String[] args) {
int num=1;
Parent p=getObj(num);
p.method();//多态：调用方法时可能会出现多种结果
//多态分类：
//静态多态：由重载造成，在类编译（javac）时就可以确定执行的是哪一个方法
//动态多态：由重写造成，只有在执行到该行代码才能确定执行的是哪一个类的方法
}
public static Parent getObj(int a) {
if(a==1) {
return new SonA();
}else if(a==2) {
return new SonB();
}else {
return new Parent();
}
}
}
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");
}
}扩展1：关于类中方法加static
在Java中，类中的方法可以被定义为静态方法（static method）或实例方法（instance method）。它们之间的区别在于调用方式和作用范围。
1. 静态方法（static method）:
静态方法是属于整个类的，而不是类的单个实例。静态方法可以直接使用类名来调用，而无需创建类的实例。静态方法一般用于提供通用的工具方法、工具类方法或类级别的操作。静态方法中不能直接访问类的非静态成员变量和非静态方法，只能访问类的静态成员变量和静态方法，也不能使用this关键字。
```java
public class MyClass{
public static void staticMethod(){
// do something
}
}
```
2. 实例方法（instance method）:
实例方法只能通过对象来调用，必须首先创建类的实例对象，然后使用实例对象来调用实例方法。实例方法能直接访问类的非静态成员变量和非静态方法，并可以使用this关键字。实例方法一般用于封装对象的行为和状态，对实例变量进行操作。
```java
public class MyClass{
public void instanceMethod(){
// do something
}
}
```
所以，当你需要一个在整个类中通用的方法，而不需要依赖于类的实例时，可以将方法定义为静态方法；当需要操作类的实例变量和实例方法时，应将方法定义为实例方法。
扩展2：重载和重写的区别
1. 重写（Override）是指子类重新定义父类中的方法，以达到特定的需求。子类在重写父类方法时，方法名称、参数列表和返回类型都必须与父类方法一致。重写是实现多态性的一种表现。
2. 重载（Overload）是指在同一个类中，允许存在多个方法名相同但参数列表不同的方法。重载方法必须具有不同的参数类型、个数或顺序。重载是通过同一方法名传递不同的参数列表以实现不同功能的方式。
因此，重写是子类重新定义父类方法，而重载是同一类中存在多个方法名相同但参数列表不同的方法的情况。二者都是Java中的多态性的表现。
（今天是真的真的累啊！虽然这些知识点在学校学过了，但是不知道为什么，再学一遍还是累，可能是因为内容难以梳理，老师讲的时候我就在思考怎么梳理写博客了，但最后还是放弃了，太累了，直接放代码吧，不过哪些易错易忽略的点我还是用红绿标记出来了，这些内容足够我复习的时候看了，个人感觉学继承、封装多态什么的就是要多打代码多思考，没什么别的好办法，加油吧！）
167
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
