一、java方法
1、什么是方法
示例
System.out.ptintln();
System是一个类,out是一个输出对象,println是方法。调用System类中的标准输出对象out中的println方法
java方法是语句的集合,在一起执行一个功能
回顾:
方法的命名规则:首字母小写驼峰原则
static方法一般称作静态方法,由于静态方法不依赖于任何对象就可以进行访问
2、方法的定义及调用
Java的方法类似于其他语言的函数,是一段用来完成特定功能的代码的片段。
方法包含一个方法头和一个方法体。
示例:
int sum = add(4,5);//实际参数:实际调用传给它的参数
System.out.println(sum);
test();
}
//加法
public static int add(int a, int b){///修饰符 返回值类型 方法名 a,b为形式参数
return a + b;
}
public static void test(){//加上static方便调用
int i = 1;
while(i<=1000){
if(i%5==0){
System.out.print(i+"\t");
}
if(i%15==0){
System.out.println();
}
i++;
}
}
方法语法
- 修饰符:可选,告诉编译器如何调用该方法,定义该方法的访问类型
- 返回值类型:无返回值用void
- 方法名:方法实际名称
- 参数类型:可选,方法被调用时,传递值给参数。值被称为实参或形参。参数列表是指方法的参数类型,顺序和参数的个数
- 方法体:具体语句,定义该方法的功能
形参与实参
1. 形参:方法被调用时用于接收外界输入的数据
2. 实参:使用方法时实际传给方法的数据
return:
-
存在返回值使用return返回
-
return****除了返回结果还能终止方法
方法调用:
1、调用方法:对象名.方法名(实参列表)
两种方式:
1、方法有返回值时,方法调用通常被当做一个值。如:
int larger = max(30,40);
2、方法返回值是void,方法调用一定是一条语句
System.*out*.println("Hello world!");
拓展:值传递和引用传递
java是值传递
3、方法重载(参数类型)
重载就是在一个类中,有相同的函数名称,但形参不同的函数
方法的重载规则:
-
方法名称必须相同
-
参数列表必须不同
-
方法的返回类型可以相同或不同
-
只有返回值类型不同不能成为方法的重载
实现理论:
方法名称相同时,编译器会根据调用方法的参数个数、参数类型等逐个去匹配,选择对应方法,匹配失败则报错.
参数个数不同或者参数个数相同,类型不同
示例:
double k = max(45.0,43.0);
int m = max(45,43);
System.out.println(k);
System.out.println(m);
}
//比大小
public static int max(int num1, int num2) {
int result;
if (num1 > num2) {
result = num1;
} else {
result = num2;
}
return result
}
public static double max(double num1, double num2){
double result;
if (num1 > num2) {
result = num1;
} else {
result = num2;
}
return result;
}
数组长度:a.length
4、命令行传参
F:\idea\javaSE\基础语法\src>java com.wangchaohong.method.Demo03 this is wangchaohong
args[0]:this
args[1]:is
args[2]:wangchaohong
5、可变参数
不定项参数
在方法声明中,在指定参数类型后加一个省略号(…)
一个方法中只能制定一个可变参数,必须是方法的最后一个参数。
示例
Demo04 demo04 = new Demo04();
demo04.method(1,2,3,4,5);
}
public void method(int... i){//i为数组名
System.out.println(i[0]);
}
6、递归
A方法自己调用自己,和A方法调用B方法没有什么区别
递归结构包括两个部分:
1、递归头:什么时候不调用自身方法,如果没有头将陷入死循环
2、递归体:什么时候需要调用自身方法
java都是栈机制
递归占用大量空间,java中能不用就不用
递归示例1
public static void main(String[] args) {
int k = 20;
int sum = test(k);
System.out.println(sum);
}
public static int test(int i){
int sum;
if(i == 0){
sum = -200;
}else{
sum = test(i-1) + i;
}
return sum;
}
递归示例2
public static void main(String[] args) {
Demo07 demo07 = new Demo07();
double sum = demo07.test(10);
System.out.println(sum);
}
public double test(double i){
double sum;
if(i==0){
sum = 1;
}else{
sum = test(i-1) * i;
}
return sum;
}
作业:写一个计算器,加减乘除,循环接收新的数据,通过用户交互实现 加减乘除
思路:
1、写四个方法(构建四个方法)
2、利用循环switch进行用户交互(利用Scanner进行用户交互)
3、传递需要操作的两个数(传参)
4、输出结果
初写:
public class TestDemo02 {
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
TestDemo02 testDemo02 = new TestDemo02();
int a = s.nextInt();
if(s.hasNext()){
String str = s.next();
switch(str){
case"+":{
int sum = testDemo02.add(a,s.nextInt());
System.out.println(sum);
break;
}
case"-":{
int sum = testDemo02.subtract(a,s.nextInt());
System.out.println(sum);
break;
}
case"*":{
int sum = testDemo02.mul(a,s.nextInt());
System.out.println(sum);
break;
}
case"/":{
int sum = testDemo02.div(a,s.nextInt());
System.out.println(sum);
break;
}
}
}
}
public int add(int a, int...b){//加
int sum = a;
for (int i = 0; i < b.length; i++) {
sum = sum + b[i];
}
return sum;
}
public int subtract(int a, int...b){//减
int sum = a;
for (int i = 0; i < b.length; i++) {
sum = sum - b[i];
}
return sum;
}
public int mul(int a, int...b){//乘
int sum = a;
for (int i = 0; i < b.length; i++) {
sum = sum * b[i];
}
return sum;
}
public int div(int a, int...b){//除
int sum = a;
for (int i = 0; i < b.length; i++) {
sum = sum / b[i];
}
return sum;
}
}
注意:每次输入之间应有空格
二、java数组
1、数组概述
-
数组是相同数据类型的有序集合
-
数组描述的是相同类型的若干个数据,按照一定的先后顺序排列组合而成
-
每一个数据称为数组元素,每个元素可以通过一个下表来访问
2、数组声明创建
必须先声明数组变量,才能使用
语法:
dataType[] arrayRefVar;首选——String[] args
dataType arrayRefVar[];非首选
java语言使用new操作符来创建数组,语法如下:
dataType[] arrayRefVar = new dataType[arraySize]
数组元素通过索引访问,索引从0开始
数组长度:array.length
内存分析:Java内存分析
示例:
public static void main(String[] args) {
//变量的类型 变量名字 变量值;
//数组类型
int[] nums;//定义1,建议用
int nums1[];//定义2 C,C++语言中
int sum = 0;
nums = new int[10];//可存放10个int类型数据,创建数组,分配空间
for (int i = 0; i < nums.length; i++) {
nums[i] = i+1;
}
for (int i = 0; i < nums.length; i++) {
System.out.println("nums["+i+"]"+"="+nums[i]);
}
System.out.println("nums["+11+"]"+"="+nums[11]);//运行至此处报错
for (int i = 0; i < nums.length; i++) {
sum = sum + nums[i];
}
System.out.println("所有元素的和为:"+sum);
}
ArrayIndexOutOfBoundsException:数组下标越界异常
Exception in thread “main” java.lang.ArrayIndexOutOfBoundsException: 11 at com.wangchaohong.array.ArrayDemo01.main(ArrayDemo01.java:17)
三种初始化:
- 静态初始化
int[] a = {1,2,3};
Man[] mans = new {new Man(1,1),new Man(2,3)}
- 动态初始化int[] a = new int[2]
a[0]=1;
a[1]=2;
- 数组的默认初始化
数组是一种引用类型,除了基本数据类型都是引用类型,它的元素相当于类的实例变量,因此数组一经分配空间,其中的每个元素也被按照实例变量同样的方式被隐式初始化
数组的四个基本特点:
-
长度确定。一旦被创建,大小不可改变
-
元素必须是相同类型
-
数组中的元素可以是任何类型,包括基本类型与引用类型
-
数组变量属引用类型,数组也可看成对象,数组中的每个元素相当于该对象的成员变量
数组本身就是对象,Java中对象是在堆中的。数组对象本身是在堆中的
数组边界问题:【0,length-1】
ArrayIndexOutOfBoundsException:数组下标越界异常
小结:数组是相同数组类型的有序集合
数组也是对象,数组的元素相当于对象的成员变量
数组长度确定,不可改
3、数组使用
1、For-Each循环(增强型)
2、数组作方法入参
3、数组作返回值
4、普通for循环
for循环示例
public class ArrayDemo03 {
public static void main(String[] args) {
int[] arrays = {1,2,3,4,5};
//打印全部数组元素
for (int i = 0; i < arrays.length; i++) {
System.out.print(arrays[i] );
}
System.out.println();
System.out.println("==============================");
//计算 所有元素的和
int sum = 0;
for (int i = 0; i < arrays.length; i++) {
sum = sum + arrays[i];
}
System.out.println(sum);
System.out.println("================================");
//查找最大元素
int max = 0;
for (int i = 0; i < arrays.length-1; i++) {
if (arrays[i]>=arrays[i+1])
max = arrays[i];
else
max = arrays[i+1];
}
System.out.println(max);
}
增强型
public class ArrayDemo04 {
public static void main(String[] args) {
int[] a = {1,2,3,4,5};
for (int i : a) {//a是数组,i是数组中的每个元素,JDK1.5
System.out.println(i);
}
printArray(a);
reverse(a);
for (int i = 0; i < a.length; i++) {
System.out.println(a[i]);
}
}
//打印数组元素
public static void printArray(int[] a){
for (int i : a) {
System.out.print(i+" ");
}
System.out.println();
}
//反转数组
public static int[] reverse(int[] a){
for (int i = 0; i < a.length / 2; i++) {
int t;
t = a[a.length-i-1];
a[a.length-i-1] = a[i];
a[i] = t;
}
return a;
}