1. 方法,在其他语言中也可称为函数
方法的语法如下:
返回值类型 方法名 (参数) { 方法体 }
public static int max(int a,int b){
int max=a>b?a:b;
return max;
//return 用来返回数据
}
public int sum(int a,int b){
int sum=a+b;
return sum;
}
public static void printMaxA(int a,int b){
//得到最大值
//调用本类中已经定义的方法
int result = max(a,b);
//打印出最大值来
System.out.println(result);
}
public static void sum(int a,int b){
Systm.out.println("总和为:"+(a+b));
}
上面第三个方法的返回值类型为void
若不需要返回值时返回值类型填写void,void中可以写return,但是不能return null
同时return表示方法结束,方法中return语句下面不可继续写代码
2.形参:形参是方法定义时,参数列表的参数名
实参:实参是调用列表时,实际传入的参数
3.方法的重载
在同一个类中,方法名相同但是参数列表不同即为重载
参数列表的三个要素:
1参数类型不同
public int method(int a){
return 0;
}
public int method(byte a){
return 0;
}
2参数个数不同
public int method(int a){
return 0;
}
public int method(int a,int b){
return 0;
}
3参数的顺序不同(注意跟形参名称a,b无关)
public int method(int a,byte b){
return 0;
}
public int method(byte a,int b){
return 0;
}
4小实例:在方法中输出数组的最大值
public static int max(int[] arr){
int max=arr[0];
for (int i=0;i<arr.length;i++){
if (arr[i]>max){
max=arr[i];
}
}
return max;
}
然后在main函数中调用max()方法,输出max的值
4.可变参数:不确定传入多少个参数时使用可变参数
可变参数的声明: (int... a)表示不确定有几个int类型的参数
可变参数的使用 : 当作数组使用
注意点: (1)一个方法中只能有一个可变参数 (2)可变参数必须放在参数列表的最后 (3)可变参数是数量可变,类型不可变 (4)调用可变参数方法可以使用数组代替(学JDBC的时候会讲) (5)可变参数可以不传
public static int sum(int... a){
int sum=0;
for(int item:a){
sum+=item; //将每一个输入的对象item加到总和sum中
}
return sum;
}
//输出语句
System.out.println(sum(1,1,2,2,3,3,4,4,5,5));
//输出结果为30
5.方法的递归
递归:方法自己调用自己(不能一直调用自己,要有条件约束)
小实例:输出阶乘 !num
public static int jiecheng(int num){
if (num==1){
return 1;
}
return num*jiecheng(num-1);
}
//输出语句
int num=jiecheng(5);//给num赋值5,求5的阶乘
System.out.println(num);//输出结果为120
6.排序算法
以冒泡排序为例:
public static void maopao(int[] arr){
for (int j=0;j<arr.length-1;j++){
//内层循环完成一次就确定一个位置的值
for (int i=0;i<arr.length-j-1;i++){//arr.length-j-1的原因是减少代码冗余
//如果前面的元素大,就交换位置(两个元素交换值)
//要考虑数组越界的可能性
if (arr[i]>arr[i+1]){
int temp=arr[i];
arr[i]=arr[i+1];
arr[i+1]=temp;
}
}
}
}
public static void main(String[] args) {
int[] arr={11,33,52,17,1,24};//定义并初始化数组
maopao(arr);调用冒泡排序方法maopao
System.out.println(Arrays.toString(arr));//数组数据处理完毕后输出
//[1, 11, 17, 24, 33, 52]
}
7.类的定义
先定义一个Staff类
public class Staff {
//在类中定义属性(属性又叫做全局变量)
String code;
String sex;
String name;
double salary;
//类的方法可以直接调用本类中的属性
public void work(){
System.out.println(name+"正在工作");
}
}
在main函数中实例化对象:
实例化对象,就是开辟内存空间
public class TestStaff {
public static void main(String[] args) {
//实例化对象(即开辟内存空间)
Staff staff = new Staff();
//设置对象的属性 类中声明了哪些属性,对象中就有哪些属性
staff.code="YG10001";
staff.name="张三";
staff.sex="男";
staff.salary=10000;
Staff staff1 = new Staff();
staff1.code="YG10002";
staff1.name="李四";
staff1.sex="女";
staff1.salary=10000;
//调用对象的方法
staff.work(); //张三在工作
staff1.work(); //李四在工作
}
}
构造方法:
构造方法用来对对象进行初始化
在Staff类下原本有一个默认为空的构造方法:
public Staff(){
}
在Staff类下写一个构造方法:
(1)局部变量 在方法体或者代码块中声明的变量 (2)全局变量 在类中定义的变量叫全局变量
在局部变量和全局变量重名的情况下,可以使用this关键字来标注全局变量:
this.name=name;
public Staff(String name){
this.name=name;
}
定义构造方法 (1)没有返回值类型 (2)构造方法的方法名和类名必须相同 (3)如果一个类没有定义任何的构造方法,系统会给一个默认的空的构造方法(4)类中一旦自定义了任意的构造方法,系统给定的默认构造方法就消失了
public class TestStaff {
public static void main(String[] args) {
Staff staff = new Staff("aaa");//在构造方法里传进参数String name
staff.code="YG10001";
staff.sex="男";
staff.salary=10000;
Staff staff1 = new Staff("bbb");
staff1.code="YG10002";
staff1.sex="女";
staff1.salary=10000;
//调用对象的方法
staff.work(); //aaa在工作
staff1.work(); //bbb在工作
}
}
8.面向对象的三大特性:
封装 继承 多态
9.封装:隐藏类中的细节,不能让其他类随意的访问
通过四个权限访问修饰符达到封装的效果:public protected default private
public公共的 protected受保护的 default默认的(本包中访问) private私有的(只能在本类中访问)
四个权限访问修饰符的范围:
10.继承:一个子类可以继承父类,子类就具有父类中定义好的属性和方法 (不是所有的属性和方法都能调用到(有访问权限才可以,public,protected,本包下出现的父类的default))
继承的好处:(1)代码重用 (2)继承是多态的基础
创建一个父类Plane:
class Plane{
String code;//向上的父类访问不到 向下的子类和本包下的类可以访问到
String color;
public Plane(String color){
this.color=color;
}
public Plane(String code, String color){
this.code=code;
this.color=color;
}
public Plane(){}
public void fly(){
System.out.println("飞机");
}
}
创建一个子类BigPlane:
extends关键字是继承的意思
注意:(1)java是单继承结构,即一个子类只能继承自一个父类
(2)java支持多重继承,即一个类能被多个子类继承
class BigPlane extends Plane{
//子父类之间的构造方法
public BigPlane(String color){
super(color);
}
public BigPlane(String code,String color){
super(code,color);
}
//重写父类的方法fly()
@Override
public void fly(){
System.out.println("重写后的飞机");
}
}
重写:子类对父类中继承过来的方法重新定义(方法重写) 可以使用@Override注解,验证方法是否是重写的方法
注意:重写的方法返回值,方法名,参数列表不能发生变化,重写的方法的访问权限只能更开放,不能更闭塞
调用父类的构造方法:
子类的构造方法的首行必须要用父类的构造方法 默认调用父类的无参构造方法 如果父类中没有没有无参构造方法,子类构造方法中必须明文声明调用父类的哪一个构造方法 使用super关键字调用父类的构造方法
public BigPlane(String color){
super(color, color);
}
public BigPlane(String code,String color){
super(code,color);
}
向上转型:
//用父类的指针指向子类的对象
public static void main(String[] args) {
BigPlane bp = new BigPlane("111");
bp.code="10011";
bp.fly();
//父类的指针指向子类的对象
Plane p = new BigPlane("222");
//调用方法看对象(看调用的是具体哪一个的对象)
//调用属性看声明(Plane)
p.fly();
}
11.多态:
创建一个父类Parent,两个子类SonA和SonB
class Parent{
public void method(){
System.out.println("父类");
}
}
class SonA extends Parent{
public void method(){
System.out.println("A类");
}
}
class SonB extends Parent{
public void method(){
System.out.println("B类");
}
}
写一个返回Parent类型值的方法getObj():
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) {
int num=1;
Parent p=getObj(num);//产生多态,因为p变量可能指向任意个子类的对象
p.method();
}
}
多态:调用方法可能出现多种结果 多态分为静态多态和动态多态 静态多态:主要是因为重载造成的,在类编译时就可以确定调用的是哪一个方法 动态多态:主要由重写造成的,只有在执行到该行代码,才能确定执行的是哪个类中的方法