网站seo推广优化,北京优化核酸检测,微信公众平台小程序注销,北京专业网页设计制作公司目录
一、成员方法
(一)方法的快速入门
(二)方法的调用机制(重要)
(三)方法的定义
(四)注意事项和使用细节
1.访问修饰符(作用是控制方法的使用范围)
2.返回的数据类型
3.方法名
4.形参列表
5.方法体
6.方法调用细节说明
(五)传参机制
1.基本数据类型的传参机制
…目录
一、成员方法
(一)方法的快速入门
(二)方法的调用机制(重要)
(三)方法的定义
(四)注意事项和使用细节
1.访问修饰符(作用是控制方法的使用范围)
2.返回的数据类型
3.方法名
4.形参列表
5.方法体
6.方法调用细节说明
(五)传参机制
1.基本数据类型的传参机制
2.引用数据类型的传参机制
2.1方法传参传入数组
2.2方法传参传入对象
2.3传参后对象null
2.4传参后创建新的对象
(六)对象的克隆
(七)方法的递归调用
1.方法的递归执行机制
2.使用递归的重要规则
3.方法递归经典题目
3.1计算n的阶乘
3.2斐波那契数列
3.3猴子吃桃问题
3.4汉诺塔
(八)方法的重载(OverLoad)
(九)可变参数
二、作用域
(一)基本使用
(二)注意事项和细节使用
(三)跨类访问对象属性的2种方式 一、成员方法
(一)方法的快速入门 在某些情况下我们需要定义成员方法(简称方法)。比如人类除了有一些属性外(年龄、姓名...)还有一些行为比如说话、跑步、唱歌...这些都要用成员方法才能完成。
方法代码示例
public class Method01 { public static void main(String[] args) {//方法使用//1. 方法写好后如果不去调用(使用)不会输出//2. 先创建对象 ,然后调用方法即可Person p1 new Person();//调用getSum方法同时num110, num220//把 方法 getSum 返回的值赋给 变量 returnResint returnRes p1.getSum(10, 20); System.out.println(getSum方法返回的值 returnRes);}
}class Person {String name;int age;//方法(成员方法)//添加getSum成员方法,可以计算两个数的和//1. public 表示方法是公开的//2. int :表示方法执行后返回一个 int 值//3. getSum 方法名//4. (int num1, int num2) 形参列表2个形参可以接收用户传入的两个数//5. return res; 表示把 res 的值 返回public int getSum(int num1, int num2) {int res num1 num2;return res;}
}
(二)方法的调用机制(重要)
下图是JVM内存中方法的调用机制分析图 成员方法的好处提高代码的复用性可以将实现的细节封装起来然后供其他用户来调用即可。
(三)方法的定义
访问修饰符 返回数据类型 方法名(形参列表){语句;return 返回值;
} 形参列表表示成员方法输出例如上面的getSum(int num1,int num2)返回数据类型表示成员方法输出void表示没有返回值方法体表示为了实现某一功能代码块return语句不是必须的当有返回数据类型时必须要有return语句 (四)注意事项和使用细节
1.访问修饰符(作用是控制方法的使用范围) 如果不写默认访问有4种public、protected、默认、private 2.返回的数据类型 一个方法最多有一个返回值要想返回多个值就可以返回一个数组返回类型可以为任意类型包含基本数据类型或引用数据类型(数组对象)如果方法要求有返回数据类型则方法体中最后的执行语句必须为return 值;而且要求返回值类型必须和return的值类型一致或兼容如果方法返回值类型是void则方法体中可以没有return语句或者只写return 3.方法名 遵循驼峰命名法最好见名知义表达出该功能的意思即可比如得到两个数的和getSum这种开发中按照规范来命名。 4.形参列表 一个方法可以有0个参数也可以有多个参数中间用逗号隔开比如getSum(int n1,int n2)参数类型可以为任意类型包含基本类型或引用类型比如printArr(int[][] map)调用带参数的方法时一定对应着参数列表传入相同类型或兼容类型的参数方法定义时的参数类型为形式参数简称形参方法调用时的传入参数称为实际参数简称实参形参和实参的类型要一致或兼容、个数、顺序必须一致 5.方法体 方法体中写完成功能的具体的语句可以为输入、输出、变量、运算、分支、循环、方法调用但是方法体里面不能再定义方法即方法不能嵌套定义。 6.方法调用细节说明 1)同一个类中的方法调用直接调用即可 public class MethodDetail {public static void main(String[] args) {A a new A();a.sayOK();// print()方法被调用 n10// 继续执行sayOK()~~~}
}class A {public void print(int n) {System.out.println(print()方法被调用 n n);}public void sayOK(){ // sayOK可以直接调用同类中其他成员方法print(10);System.out.println(继续执行sayOK()~~~);}
} 2)跨类中的方法A类调用B类方法需要通过对象名调用。比如 对象名.方法名(参数); public class MethodDetail {public static void main(String[] args) {A a new A();a.m1();}
}class B {public void hi() {System.out.println(B类中的hi()方法被执行);}
}class A {// 在A类中访问B类的方法public void m1() {System.out.println(m1()方法被调用);// 先创建B对象B b new B();// 然后再调用方法b.hi();System.out.println(m1()方法继续执行);}
} 3)特别说明跨类的方法调用和方法的访问修饰符相关。 (五)传参机制
1.基本数据类型的传参机制
基本数据类型传递的是值(值拷贝)形参的任何改变不影响实参
因为多个方法的调用会在栈中开辟各自独立的空间基本数据类型不是引用不同的方法中的变化不会互相影响。
public class MethodParameter01 {public static void main(String[] args) {AB ab new AB();int a 10;int b 20;ab.swap(a, b); //调用swapSystem.out.println(main方法 a a b b);//a10 b20}
}class AB {public void swap(int a,int b){System.out.println(\na和b交换前的值\na a \tb b);//a10 b20//完成了 a 和 b的交换int tmp a;a b;b tmp;System.out.println(\na和b交换后的值\na a \tb b);//a20 b10}
}
上述代码内存图 2.引用数据类型的传参机制
引用数据类型传递的是地址(传递也是值但是值是地址)可以通过形参影响实参!
2.1方法传参传入数组
public class TestDemo1 {public static void main(String[] args) {AAB aab new AAB();int[] arr {1, 2, 3};aab.test100(arr);System.out.println(main的arr输出 Arrays.toString(arr));// test100的arr输出[200, 2, 3]// main的arr输出[200, 2, 3]}
}class AAB {// test100方法接收一个数组在方法中修改数组public void test100(int[] arr) {arr[0] 200;System.out.println(test100的arr输出 Arrays.toString(arr));}
} 2.2方法传参传入对象
public class TestDemo1 {public static void main(String[] args) {AAB aab new AAB();Person p new Person();p.name jack;p.age 10;aab.test200(p);System.out.println(main 的p.age p.age); // 10000}
}class Person {String name;int age;
}class AAB {public void test200(Person p) {p.age 10000;// 修改对象属性}
} 2.3传参后对象null
public class TestDemo1 {public static void main(String[] args) {AAB aab new AAB();Person p new Person();p.name jack;p.age 10;aab.test200(p);System.out.println(main 的p.age p.age); // 10}
}class Person {String name;int age;
}class AAB {public void test200(Person p) {
// p.age 10000;// 修改对象属性p null;}
} 2.4传参后创建新的对象
public class TestDemo1 {public static void main(String[] args) {AAB aab new AAB();Person p new Person();p.name jack;p.age 10;aab.test200(p);System.out.println(main 的p.age p.age); // 10}
}class Person {String name;int age;
}class AAB {public void test200(Person p) {
// p.age 10000;// 修改对象属性
// p null;p new Person();p.name tom;p.age 99;}
} (六)对象的克隆 对象的克隆编写一个方法copyPerson可以复制一个Person对象返回复制的对象 注意要求得到新对象和原来的对象是两个独立的对象只是他们的属性相同 编写方法的思路 1.方法的返回值类型Person 2.方法的名字copyPerson 3.方法的形参(Person p) 4.方法体创建一个新对象并复制属性返回即可 代码如下
public class TestDemo1 {public static void main(String[] args) {AAB aab new AAB();Person p new Person();p.name alice;p.age 12;Person p2 aab.copyPerson(p);System.out.println(p的hashCode p.hashCode() 姓名 p.name 年龄 p.age);// p的hashCode1163157884 姓名alice 年龄12System.out.println(p2的hashCode p2.hashCode() 姓名 p2.name 年龄 p2.age);// p2的hashCode1956725890 姓名alice 年龄12System.out.println(p p2); // false}
}class Person {String name;int age;
}class AAB {public Person copyPerson(Person p) {Person p2 new Person();p2.name p.name;p2.age p.age;return p2;}
} (七)方法的递归调用
1.方法的递归执行机制 递归就是方法自己调用自己每次调用时传入不同的变量。递归有助于解决复杂问题同时可以让代码变得简洁。方法的递归就是栈不断地开辟后直到遇到返回条件才会一个个关闭。
给出一段代码画出内存图
public class Recursion01 {public static void main(String[] args) {T t1 new T();t1.test(4);}
}class T {public void test(int n) {if (n 2) {test(n - 1);}System.out.println(n n);}
} 上面的结果输出 当添加else分支后只会输出2因为其他的方法没有打印部分只有当n2的时候才会打印
public void test(int n) {if (n 2) {test(n - 1);} else {System.out.println(n n);}}
2.使用递归的重要规则 执行一个方法时就创建一个新的受保护的独立空间(栈空间)方法的局部变量是独立的不会相互影响比如n变量如果方法中使用的是引用类型变量(比如数组、对象)就会共享该引用类型的数据递归必须向退出递归的条件逼近否则就是无限递归出现StackOverflowError当一个方法执行完毕或者遇到return就会返回遵守谁调用就将结果返回给谁同时当方法执行完毕或者返回时该方法也就执行完毕。 3.方法递归经典题目
3.1计算n的阶乘
public class Recursion01 {public static void main(String[] args) {T t1 new T();int result t1.factorial(5);System.out.println(result);}
}class T {public int factorial(int n) {if (n 1) {return 1;} else {return factorial(n - 1) * n;}}
}
计算n的阶乘内存图 3.2斐波那契数列 请使用递归的方式求出斐波那契数1,1,2,3,5,8,13...给你一个整数n求出它的值是多 思路分析 1. 当n 1 斐波那契数 是1 2. 当n 2 斐波那契数 是1 3. 当n 3 斐波那契数 是前两个数的和 4. 这里就是一个递归的思路 public class TestDemo1 {public static void main(String[] args) {T t new T();System.out.println(t.fibonacci(7)); // 13}
}class T {public int fibonacci(int n) {if (n 1) {if (n 1 || n 2) {return 1;} else {return fibonacci(n - 1) fibonacci(n - 2);}}else {System.out.println(您的输入有误!);return -1;}}
}
3.3猴子吃桃问题 猴子吃桃问题有一堆桃子猴子第一天吃了其中的一半并再多吃了一个以后每天猴子都吃其中的一半然后再多吃一个。当到第10天想再吃时即还没吃发现只有1个桃子了。问题最初共多少个桃子 思路分析——逆推 1. day 10 时 有 1个桃子 2. day 9 时 有 (day10 1) * 2 4 3. day 8 时 有 (day9 1) * 2 10 4. 规律就是 前一天的桃子 (后一天的桃子 1) *2 后一天的桃子 day 1 5. 递归 public class TestDemo1 {public static void main(String[] args) {
// demo1();T t new T();System.out.println(t.peach(1)); // 1534}private static void demo1() {// 已知第10天剩下1个桃子int peachesOnTenthDay 1;// 逆向推算到第一天for (int i 9; i 1; i--) {// 每一天的桃子数量是前一天的桃子数量加1的两倍peachesOnTenthDay (peachesOnTenthDay 1) * 2;}// 输出第一天摘的桃子数量System.out.println(第一天猴子共摘了 peachesOnTenthDay 个桃子。);}
}class T {public int peach(int day) {if (day 10) {return 1;} else if (day 1 day 9) {return (peach(day 1) 1) * 2;} else {System.out.println(day在1-10);return -1;}}
}
3.4汉诺塔 汉诺塔汉诺塔又称河内塔问题是源于印度一个古老传说的益智玩具。大梵天创造世界的时候做了三根金刚石柱子 在一根柱子上从下往上按照大小顺序摞着64片圆盘。大梵天命令婆罗门把圆盘从下面开始按大小顺序重新摆放在另一 根柱子上。并且规定在小圆盘上不能放大圆盘在三根柱子之间一次只能移动一个圆盘。
public class TestDemo1 {public static void main(String[] args) {T t new T();t.tower(3, A, B, C);}
}class T {//num 表示要移动的个数, a, b, c 分别表示A塔B 塔, C 塔public void tower(int num, char a, char b, char c) {// 如果只有一个盘num 1if (num 1) {// 把a移动到c即可System.out.println(a - c);} else {//如果有多个盘可以看成两个 , 最下面的和上面的所有盘(num-1)//(1)先移动上面所有的盘到 b, 借助 ctower(num - 1, a, c, b);//(2)把最下面的这个盘移动到 cSystem.out.println(a - c);//(3)再把b塔的所有盘移动到c ,借助atower(num - 1, b, a, c);}}
}
以3个圆盘为例结果 (八)方法的重载(OverLoad) Java中允许同一个类中多个同名方法的存在但要求形参列表不一致。重载减轻了起名和记名的麻烦。
注意事项和使用细节 方法名必须相同形参列表必须不同(形参类型或个数或顺序至少有一样不同参数名无要求返回类型无要求 方法重载示例
public class OverLoad01 { public static void main(String[] args) {// System.out.println(100);// System.out.println(hello,world);// System.out.println(h);// System.out.println(1.1);// System.out.println(true);// MyCalculator mc new MyCalculator();System.out.println(mc.calculate(1, 2));System.out.println(mc.calculate(1.1, 2));System.out.println(mc.calculate(1, 2.1));}
}class MyCalculator {//下面的四个 calculate方法构成了重载//两个整数的和public int calculate(int n1, int n2) {System.out.println(calculate(int n1, int n2) 被调用);return n1 n2;}//没有构成方法重载, 仍然是错误的因为是方法的重复定义// public void calculate(int n1, int n2) {// System.out.println(calculate(int n1, int n2) 被调用);// int res n1 n2;// } // 没有构成方法重载也是方法的重复定义// public int calculate(int a1, int a2) {// System.out.println(calculate(int n1, int n2) 被调用);// return a1 a2;// } //一个整数一个double的和public double calculate(int n1, double n2) {return n1 n2;}//一个double ,一个int的和 public double calculate(double n1, int n2) {System.out.println(calculate(double n1, int n2) 被调用..);return n1 n2;}//三个int的和public int calculate(int n1, int n2,int n3) {return n1 n2 n2;}
}
(九)可变参数
注意事项和使用细节 可变参数的实参可以为0个或任意多个。可变参数的实参可以为数组可变参数的本质就是数组可变参数可以和普通类型的参数一起放在形参列表但必须保证可变参数在最后一个形参列表中只能出现一个可变参数 public class TestDemo1 {public static void main(String[] args) {T t new T();int[] arr {1, 2, 3};t.sum(arr); // 传入数组t.sum(1, 5, 9); // 传入多个参数}
}class T {// 参数列表可变public void sum(int... nums) {int n 0;for (int i 0; i nums.length; i) {n nums[i];}System.out.println(接收的参数个数 nums.length);System.out.println(和为 n);}
}
public class TestDemo1 {public static void main(String[] args) {T t new T();String res t.showScore(张三, 85.6, 90.5, 60);System.out.println(res);// 张三的3门课程总分为236.1}
}class T {// 参数列表可变public String showScore(String name, double... num) {double sum 0;for (double score : num) {sum score;}return name 的 num.length 门课程总分为 sum;}
}
二、作用域
(一)基本使用 在Java编程中主要的变量就是属性(成员变量)和局部变量。局部变量一般是指在成员方法中定义的变量。全局变量属性作用域为整个类体局部变量除了属性之外的其他变量作用域为定义它的代码块中。全局变量(属性)可以不赋值直接使用因为有默认值局部变量必须赋值后才能使用因为没有默认值。细节: 属性可以加修饰符(public protected private..)局部变量不能加修饰符。 (二)注意事项和细节使用 属性和局部变量可以重名访问时遵循就近原则。在同一个作用域中比如在同一个成员方法中两个局部变量不能重名。属性生命周期较长伴随着对象的创建而创建伴随着对象的销毁而销毁局部变量生命周期较短伴随着它的代码块的执行而创建伴随着代码块的结束而销毁。即在一次方法调用过程中。全局变量/属性可以被本类使用或其他类使用(通过对象调用)局部变量只能在本类中对应的方法中使用。全部变量/属性可以加修饰符局部变量不可以加修饰符。 (三)跨类访问对象属性的2种方式
public class TestDemo1 {public static void main(String[] args) {T t new T();t.test(); // 第1种跨类访问对象属性的方式Person p new Person();t.test2(p);// 第2种跨类访问对象属性的方式}
}class T {// 参数列表可变public void test() {Person p1 new Person();System.out.println(p1.name);}public void test2(Person p) {System.out.println(p.name);}
}class Person {String name jack;public void say() {String name king; // 属性和局部变量可以重名访问时遵循就近原则System.out.println(say() name name);}
}
