day3.edu_01
有明确返回值的方法调用:
A:单独调用
没有意义
B:输出调用
不是特别好,因为我们可能需要对结果进行进一步的操作。
C:赋值调用
推荐方案
需求:定义一个两个数求和的方法
修饰符:public static
返回值类型:int
方法名:add
参数列表:int a,int b
方法体:{
int c = a+ b;
return c;
}
注意:定义一个方法一定要做到两个明确
1.方法的参数类型和参数个数
2.方法的返回值类型
package com.edu_01;
public class FunctionDemo2 {
public static void main(String[] args) {
//方法的调用一定是在main方法中被调用,因为main方法是一个程序的入口
//A:单独调用,没有太大的意义
//方法调用一定是传递的实际参数
//add(10, 20);
//B:输出调用
//System.out.println(add(10, 20));
//C:赋值调用,方便我们后面对这个变量的进一步操作
//注意:方法的调用需要遵循:
// 1.要啥类型的参数传递啥类型的参数
// 2.返回什么类型的值,就使用什么类型的变量接受 int d = add(10, 20);
System.out.println(d);
}
//方法与方法之间是平行关系,定义一个方法必须是在类中其他方法外
public static int add(int a,int b){
int c = a+ b;
return c;
}
}
day3.edu_02
需求:求两个数据和的功能。
返回值:有,int
参数列表:int a,int b
package com.edu_01;
public class FunctionDemo3 {
public static void main(String[] args) {
System.out.println(add(10, 20));
}
public static int add(int a,int b){
return a+b;
}
}
day3.edu_03
需求:写一个功能实现返回两个数的较大值。
要求:数据来自于键盘录入。
做到两个明确:
返回值
结果的数据类型int
参数
参数的个数2,以及类型int
package com.edu_01;
import java.util.Scanner;
public class FunctionDemo4 {
public static void main(String[] args) {
//创建键盘录入对象并导包
Scanner sc = new Scanner(System.in);
//获取键盘录入数据
System.out.println("请输入第一个数据");
int a = sc.nextInt();
System.out.println("请输入第二个数据");
int b = sc.nextInt();
//调用求最大值的方法
int max = getMax(a, b);
System.out.println(max);
}
public static int getMax(int a,int b){
int c = a>b?a:b;
return c;
}
}
day3.edu_04
写一个功能实现比较两个数据是否相等。
要求,数据来自于键盘录入。
做到两个明确:
返回值
结果的数据类型:布尔类型
参数
参数的个数2,以及类型int
package com.edu_01;
import java.util.Scanner;
public class FunctionDemo5 {
public static void main(String[] args) {
//创建键盘录入对象并导包
Scanner sc = new Scanner(System.in);
System.out.println("请输入第一个数据");
int a = sc.nextInt();
System.out.println("请输入第二个数据");
int b = sc.nextInt();
//调用方法进行判断
System.out.println(isEquals(a, b));
}
public static boolean isEquals(int a,int b){
// boolean flag = a==b;
// return flag;
return a==b;
}
}
day3.edu_05
需求1:请在控制台输出4行5列的星形。
需求2:请在控制台输出6行7列的星形。
需求3:请在控制台输出8行9列的星形。
(最终封装成方法进行调用)
package com.edu_01;
public class FunctionDemo6 {
public static void main(String[] args) {
//需求1:请在控制台输出4行5列的星形。
/**
* 这里是for循环的嵌套,
* 外层for循环控制行,
* 内层for循环控制列,
* 外层走一次,内层走一轮
*/
/*for (int i = 0; i < 4; i++) {
for(int j = 0;j<5;j++){
System.out.print("*");
}
//添加一个换行符
System.out.println();
}*/
//需求2:请在控制台输出6行7列的星形。
/*for (int i = 0; i < 6; i++) {
for (int j = 0; j < 7; j++) {
System.out.print("*");
}
System.out.println();
}*/
//需求3:请在控制台输出8行9列的星形。
/*for (int i = 0; i < 8; i++) {
for (int j = 0; j < 9; j++) {
System.out.print("*");
}
System.out.println();
}*/
//printXing(10, 8);
printXing(5, 6);
}
/**
* 封装打印成星星的方法
* 分析:
* 参数列表:2,int
* 返回值:无
*/
public static void printXing(int row,int col){
for (int i = 0; i < row; i++) {
for (int j = 0; j < col; j++) {
System.out.print("*");
}
System.out.println();
}
}
}
day3.edu_06
需求:键盘录入三个数据,返回三个数中的最大值(写成一个方法可以直接调用并且返回值)
package com.edu_01;
public class FunctionDemo7 {
public static void main(String[] args) {
System.out.println(getMax(10, 5, 8));
}
public static int getMax(int a,int b,int c){
int max ;
if (a>b) {
//a大
if (a>c) {
//a最大
max = a;
}else {
//c最大
max = c;
}
}else {
//b大
if (b>c) {
//b
max = b;
}else {
//c
max = c;
}
}
return max;
}
}
day3.edu_07
方法重载:
前提:在同一个类中
允许存在一个以上的同名方法,只要它们的参数个数或者参数类型不同即可。
需求1:求两个数据和
需求2:求三个数据和
需求3:求四个数据和
package com.edu_02;
public class FunctionOverload {
public static void main(String[] args) {
//调用下面的两个参数的加法
System.out.println(add(10, 20));
//调用下面的三个参数的加法
System.out.println(add(10, 20, 30));
}
//需求1:求两个数据和
public static int add(int a,int b){
System.out.println("两个参数的被调用");
return a+b;
}
//需求2:求三个数据和
public static int add(int a,int b,int c){
System.out.println("三个参数的被调用");
return a+b+c;
}
//需求3:求四个数据和
public static String add(String a,String b){
System.out.println("四个参数的被调用");
return a+b;
}
}
day3.edu_08
需求:比较两个数据是否相等。参数类型分别为两个byte类型,两个short类型,两个int类型,两个long类型,并在main方法中进行测试
package com.edu_02;
public class FunctionOverload2 {
public static void main(String[] args) {
//定义两个int类型的数据,进行比较
int a = 10;
int b = 20;
System.out.println(isEquals(a, b));
}
public static boolean isEquals(byte a,byte b){
System.out.println("比较两个byte类型的数据是否相等");
return a==b;
}
public static boolean isEquals(short a,short b){
System.out.println("比较两个short类型的数据是否相等");
return a==b;
}
public static boolean isEquals(int a,int b){
System.out.println("比较两个int类型的数据是否相等");
return a==b;
}
public static boolean isEquals(long a,long b){
System.out.println("比较两个long类型的数据是否相等");
return a==b;
}
}
day3.edu_09
如何为数组进行初始化:
动态初始化:初始化时只指定数组长度,由系统为数组分配初始值。
动态初始化:
初始化时只指定数组长度,由系统为数组分配初始值。
格式:
数据类型[] 数组名 = new 数据类型[数组长度];
数组长度其实就是数组中元素的个数。
package com.edu_03;
public class ArrayDemo2 {
public static void main(String[] args) {
//创建一个int类型的数组,这个数组的长度为3
//动态的初始化了一个数组
int[] arr = new int[3];
System.out.println(arr);//[I@33abb81e,这是一个地址值
System.out.println(arr[0]);//0
System.out.println(arr[1]);//0
System.out.println(arr[2]);//0
//再给每一个元素进行赋值
arr[0] = 10;
arr[1] = 20;
arr[2] = 30;
System.out.println(arr);//[I@33abb81e,这是一个地址值
System.out.println(arr[0]);//10
System.out.println(arr[1]);//20
System.out.println(arr[2]);//30
}
}
day3.edu_10
需求:定义一个数组,分别输出数组名及元素。然后分别给数组中的元素赋值,分别再次输出数组名及元素。
package com.edu_03;
public class ArrayDemo3 {
public static void main(String[] args) {
int[] arr = new int[3];
System.out.println(arr);//[I@33abb81e
System.out.println(arr[0]);//0
System.out.println(arr[1]);//0
System.out.println(arr[2]);//0
System.out.println("-----------");
arr[1] = 30;
arr[2] = 40;
System.out.println(arr);//地址值
System.out.println(arr[0]);//0
System.out.println(arr[1]);//30
System.out.println(arr[2]);//40
}
}
day3.edu_11
需求:定义两个数组,先定义一个数组,赋值,输出。
然后定义第二个数组的时候把第一个数组的地址赋值给第二个数组。
然后给第二个数组赋值,再次输出两个数组的名及元素。
package com.edu_03;
public class ArrayDemo4 {
public static void main(String[] args) {
int[] arr = new int[3];
arr[0] = 10;
arr[1] = 20;
arr[2] = 30;
//输出数组中的元素
System.out.println(arr[0]);//10
System.out.println(arr[1]);//20
System.out.println(arr[2]);//30
System.out.println("-----------------");
int[] arr2 = arr;
arr2[1] = 300;
arr2[2] = 200;
System.out.println(arr[1]);//300
System.out.println(arr[2]);//200
}
}
day3.edu_12
静态初始化:初始化时指定每个数组元素的初始值,由系统决定数组长度。
静态初始化:初始化时指定每个数组元素的初始值,由系统决定数组长度。
格式:
数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…};
简化格式:
数据类型[] 数组名 = {元素1,元素2,…};
package com.edu_03;
public class ArrayDemo5 {
public static void main(String[] args) {
//使用静态初始化一个int数组(标准格式)
/* int[] arr = new int[]{1,3,5,6};
System.out.println(arr);//[I@33abb81e
System.out.println(arr[0]);//1
System.out.println(arr[1]);//3
System.out.println(arr[2]);//5
System.out.println(arr[3]);//6
*/
System.out.println("------------------");
//使用静态初始化一个数组(简化格式)
int[] arr2 = {10,30,20};
System.out.println(arr2);//[I@7f39ebdb
System.out.println(arr2[0]);//10
System.out.println(arr2[1]);//30
System.out.println(arr2[2]);//20
}
}
day3.edu_13
数组操作常见的两个小问题
A:
ArrayIndexOutOfBoundsException:数组索引越界异常
怎么产生的:
你访问了不存在的索引。
如何解决:
修改你的访问索引。
B:
NullPointerException:空指针异常
怎么产生的:
引用已经不再指向堆内存
如何解决:
一般来说,只要是引用类型的变量,我们在使用前,都要先判断是否为null。
如果不为null,才继续使用。
package com.edu_03;
public class ArrayDemo6 {
public static void main(String[] args) {
//静态初始化一个数组,使用简化格式
int[] arr = {1,3,5,6};
//取出数组中的每一个元素
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
System.out.println(arr[3]);
//System.out.println(arr[4]);
/**
* java.lang.ArrayIndexOutOfBoundsException:数组索引越界异常
* ,不能访问超过数组最大索引的元素,如果访问就会报出这个数组索引越界异常
*/
//arr = null;
/**
* java.lang.NullPointerException:空指针异常,说白了此刻我的引用
* 毫无指向
*/
System.out.println(arr[1]);
}
}
day3.edu_14
数组遍历:
依次输出数组中的每一个元素
数组遍历标准格式:
for(int x=0; x<数组名.length; x++) {
System.out.println(数组名[x]);
}
练习:
自己定义一个数组,并遍历。
package com.edu_03;
public class ArrayDemo7 {
public static void main(String[] args) {
//定义一个数组
int[] arr = {1,3,5,6};
//遍历
// System.out.println(arr[0]);
// System.out.println(arr[1]);
// System.out.println(arr[2]);
// System.out.println(arr[3]);
//使用for循环改进数组遍历的方法
//数组的长度,怎么获取,通过数组的length属性获取数组的长度
//System.out.println(arr.length);
for(int i=0;i<arr.length;i++){
System.out.print(arr[i]+" ");
}
}
}
day3.edu_15
需求:我们可能有很多个数组需要遍历,所以我们把遍历写成一个功能。
package com.edu_03;
public class ArrayDemo8 {
public static void main(String[] args) {
//定义一个数组
int[] arr = {5,6,7,8};
printArray(arr);
}
/**
* 分析:
* 参数列表:1,int[]
* 返回值:无
*/
public static void printArray(int[] arr){
//拿到arr作何操作???
for (int i= 0;i<arr.length;i++) {
//打印数组中的每一个元素
System.out.print(arr[i]+",");
}
}
}
day3.edu_16
数组获取最值(获取数组中的最大值最小值)
package com.edu_03;
public class ArrayDemo9 {
public static void main(String[] args) {
int[] arr = {5,7,9,10};
//假设数组中的第一个元素就是最大值
int max = arr[0];
//for循环遍历数组,在for循环中进行比较判断
for (int i = 0; i < arr.length; i++) {
if (arr[i]>max) {
max = arr[i];
}
}
System.out.println(max);
}
}
day3.edu_17
package com.edu_05;
public class Student {
//成员变量:位于类中方法外
String name;
int age;
//成员方法:没有static,方法与方法之间是平性关系
public void eat(){
System.out.println("学生爱吃米饭");
}
public void study(){
System.out.println("吃饱了该学习了");
}
public void makePlane(){
System.out.println("学生会制造飞机模型");
}
}
package com.edu_05;
public class Test {
public static void main(String[] args) {
//创建一个学生对象
//类名 对象名 = new 类名();
Student s = new Student();
//打印一下这个学生对象的姓名和年龄
//System.out.println(s.name);//null
//System.out.println(s.age);//0
//给学生对象的姓名和年龄赋值
s.name = "刘德华";
s.age = 50;
System.out.println(s.name);//刘德华
System.out.println(s.age);//50
//试用一下学生的成员方法
s.eat();
s.makePlane();
s.study();
}
}
day3.edu_18
package com.edu_06;
public class Phone {
//成员变量
String brand;
int price;
//成员方法
public void call(String name){
System.out.println(name+"正在给我打电话");
}
//玩游戏
public void playGame(){
System.out.println("手机可以玩游戏");
}
}
package com.edu_06;
public class Test {
public static void main(String[] args) {
//创建手机对象
Phone p = new Phone();
//打印手机的品牌和价格
System.out.println(p.brand);
//null,因为brand是String类型,引用类型
System.out.println(p.price);//0
//给手机的成员变量赋值
p.brand = "oppo";
p.price = 2000;
System.out.println(p.brand);
System.out.println(p.price);
//调用成员方法
p.call("刘德华");
p.playGame();
}
}
day3.edu_19
如果一个文件中需要写多个类的话需要注意以下几点:
1.main方法所在的类名必须和文件名相同
2.类与类之间是平行关系
package com.edu_07;
public class PhoneTest {
public static void main(String[] args) {
//如何使用Phone这个类
//创建对象使用里面的成员变量
Phone p = new Phone();
p.brand = "苹果";
p.price = 5000;
System.out.println(p.brand);
System.out.println(p.price);
//调用成员方法
p.call();
p.playGame();
}
}
//定义一个手机类
class Phone{
//成员变量
String brand;
int price;
//成员方法
public void call(){
System.out.println("刘德华给我打电话");
}
public void playGame(){
System.out.println("郭德纲约我打游戏");
}
}
day3.edu_20
成员变量和局部变量的区别:
A:在类中的位置不同
成员变量 类中方法外
局部变量 方法内或者方法声明上
B:在内存中的位置不同
成员变量 堆内存
局部变量 栈内存
C:生命周期不同
成员变量 随着对象的存在而存在,随着对象的消失而消失
局部变量 随着方法的调用而存在,随着方法的调用完毕而消失
D:初始化值
成员变量 有默认初始化值
局部变量 没有默认初始化值
package com.edu_08;
public class VariableDemo {
int age;//成员变量,位于类中方法外
public void add(int a, int b){//局部变量位于方法中或者方法上
int c = a+b;
System.out.println(a+b);
}
public void show(){
int d;
//d是一个局部变量,在此时他并没有被初始化,没有被初始化的变量不能使用
//局部变量系统不会给一个默认的初始化值
//System.out.println(d);
}
}
day3.edu_21
匿名对象
匿名对象:就是没有名字的对象
是对象一种简写形式。
应用场景:
A:调用方法(对象调用方法仅仅一次的时候)
B:作为实际参数传递
package com.edu_09;
public class MyMath {
//创建一个加法
public int add(int a,int b){
return a+b;
}
}
day3.edu_22
匿名对象
匿名对象:就是没有名字的对象
是对象一种简写形式。
应用场景:
A:调用方法(对象调用方法仅仅一次的时候)
B:作为实际参数传递
package com.edu_09;
public class MyMath {
//创建一个加法
public int add(int a,int b){
return a+b;
}
}
package com.edu_09;
class Student{
public void show(){
System.out.println("student的show方法");
}
}
class StudentDemo{
public void method(Student s){//需要的实际参数一定是Student类的对象的的地址值
s.show();
}
}
public class StudentTest {
public static void main(String[] args) {
/* //我现在需要调用StudentDemo中的method()方法
StudentDemo sd = new StudentDemo();
//需要的实际参数一定是Student类的对象的的地址值
Student s = new Student();
sd.method(s);*/
System.out.println("--------------------------");
//想调用我现在需要调用StudentDemo中的method()方法
//使用匿名对象调用方法,并传递参数
new StudentDemo().method(new Student());
}
}
package com.edu_09;
public class Test {
public static void main(String[] args) {
//创建MyMath类的实力对象
MyMath my = new MyMath();
//调用里面的加法
int sum = my.add(10, 20);
System.out.println(sum);
}
}