JavaSE02
博主学习视频：b站狂神说Java
方法
Java方法是语句的集合，它们在一起执行一个功能。
-
方法是解决一类问题的步骤的有序组合
-
方法包含于类与对象中
-
方法在程序中创建后，可以被调用
设计方法的原则：设计方法时，最好保持方法的原子性，即一个方法只完成一个功能，方便后期的扩展。
public class Demo {
public static void main(String[] args) {
int x = 1, y = 2;
int sum = add(x,y);
System.out.println(sum);
}
public static int add(int a, int b) {
return a+b;
}
}
修饰符 返回值类型 方法名（参数类型 参数名）{
……
方法体
……
return 返回值；
}
参数类型：
形式参数：当方法被调用时用于接受外界输入的数据 (上文中的x、y）。
形参：调用方法时实际传给方法的参数 (上文中的a、b）。
值传递和引用传递
- 值传递是对基本型变量而言的,传递的是该变量的一个副本,改变副本不影响原变量.
- 引用传递一般是对于对象型变量而言的,传递的是该对象地址的一个副本, 并不是原对象本身 。
一般认为，java内的基础类型数据传递都是值传递。java中实例对象的传递是引用传递
int num = 10; //基础类型，值直接保存在变量中
String str = "hello"; //引用类型，变量中保存的是实际对象的地址。
重载
重载就是在一个类中，有相同的函数名称，但形参不同的函数。（方法同名）
重载规则
- 方法名称必须相同。
- 参数列表必须不同（个数||类型||参数排列顺序）。
- 方法的返回类型可以相同也可以不同。
- 仅仅返回类型不同不足以成为方法的重载。
在实际应用中，方法名称相同时，编译器会根据调用方法的参数个数、参数类型等逐个去匹配，以选择对应的方法；如何匹配失败，则编译器报错。
命令行传参
Demo03.java：
package com.javase.method;
import java.util.Arrays;
public class Demo03 {
public static void main(String[] args) {
//args.length 数组长度
for (int i = 0; i < args.length; i++) {
System.out.println("args["+i+"]:"+args[i]);
}
}
}
打开cmd窗口：
E:\Android\vijava-master\QQLearn\src\main\java\com\javase\method>javac Demo03.java
=========
E:\Android\vijava-master\QQLearn\src\main\java>java com.javase.method.Demo03 this is CN
args[0]:this
args[1]:is
args[2]:CN
可变参数
在方法声明中，在指定参数类型后加一个省略号(…)。
一个方法中只能指定一个可变参数，而且必须为最后一个参数。
public class Demo {
public static void main(String[] args) {
Demo04 demo04 = new Demo04();
demo04.test(1,1,3,6,8,9);
}
public void test(int x,int... i){
System.out.println(x); //1
System.out.println(i[0]); //1
System.out.println(i[1]); //3
System.out.println(i[2]); //6
System.out.println(i[3]); //8
System.out.println(i[4]); //9
System.out.println(i); //[I@14ae5a5 对象
}
}
public class Demo {
public static void main(String[] args) {
printMax(34, 3, 3, 2, 56.5);
printMax(new double[]{1,2,3});
printMax();
}
public static void printMax(double... numbers){
if (numbers.length == 0){
System.out.println("空空如也");
return; //终止方法
}
double result =numbers[0];
for (int i = 1; i < numbers.length; i++) { //排序
if (numbers[i] > result){
result = numbers[i];
}
}
System.out.println("最大值为：" + result);
}
}
递归
A方法调用A方法 (俄罗斯套娃！)
递归结构：
- 递归头：什么时候不调用自身方法，避免陷入死循环
- 递归体：什么时候需要调用自身方法
| 方法调用→ | 前阶段 → | 边界条件 ↓ |
|---|---|---|
| ↑ | 返回阶段← | ← |
public class Demo {
public static void main(String[] args) {
System.out.println(f(5));
}
//5!阶乘 5*4*3*2*1
public static int f(int n){
if(n==1){
return 1;
}else {
return n*f(n-1);
}
}
}
方便了程序员，难为了计算机（栈溢出）的方法，能不用尽量不用。用公司的计算机时可以不用考虑这个
练习
scanner.next().charAt(0);//接收键盘输入的字符串，并且取出它的第一个字符。
public class test {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
double a = scanner.nextDouble();
while(!scanner.hasNext("=")){ //检测到“=”时结束循环
char c = scanner.next().charAt(0);
double b = scanner.nextDouble();
switch (c){
case'+':
a = add(a,b);
break;
case'-':
a=cut(a,b);
break;
case'*':
a=multiply(a,b);
break;
case'/':
a=divide(a,b);
break;
default:
System.out.println("输入不符合规范！");
}
}
System.out.println("最终结果为："+a);
scanner.close();
}
public static double add(double a, double b){
return a+b;
}
public static double cut(double a, double b){
return a-b;
}
public static double multiply(double a, double b){
return a*b;
}
public static double divide(double a, double b){
return a/b;
}
}
2 * 4 - 89 =
最终结果为：-81.0
简单计算器，每个输入之间必须空格，而且严格按照从左到右的顺序执行，有点失败o(TヘTo)
数组
数组是相同类型数据的有序集合。
数组声明创建：
- 首先必须声明数组变量，才能在程序中使用数组。
dataType[] arrayRefVar; //首选的方法
或
dataType arrayRefVar[]; //效果相同
- Java语言使用new操作符来创建数组
dataType[] arrayRefVar = new dataType[arraySize];
- 数组的元素是通过索引访问的，数组索引从0开始
- 获取数组长度：
Arrays.length
int[] nums; //定义：声明一个数组
//int nums[]; //符合c语言习惯的定义
nums = new int[10]; //创建一个数组
//int[] nums = new int[10];
//赋值
nums[0]=1;
nums[1]=2;
内存分析
Java内存：
-
堆：存放new的对象和数组
可以被所有的线程共享，不会存放别的对象引用
-
栈：存放基础类型变量（包括此基本类型变量的具体数值）
引用对象的变量（会存放这个引用在堆中的具体地址）
-
方法区：可以被所有的线程共享
包含了所有的class和static变量
JAVA中的栈和堆 - 博客园 (cnblogs.com))
初始化
- 静态初始化
//静态初始化:创建加赋值
int[] a = {1,2,3,4,5,6,7,8};
- 动态初始化
//动态初始化：包含默认初始化
int[] b = new int[10];
b[0] = 1;
b[1] = 2;
- 数组的默认初始化
- 数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量的方式被默认初始化。
基本特点
- 数组长度是确定的。一旦被创建，大小不允许更改。
- 数组元素必须是相同类型，不允许出现混合类型。
- 数组中的元素可以是任何数据类型，包括基础类型和引用类型。
- 数组变量属于引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。数组对象本身是在堆中的。
数组下标的合法区间：[0,length-1]，越界就会报错
ArrayIndexOutOfBoundsException：数组下标越界异常
数组使用
普通for循环：
public class Demo {
public static void main(String[] args) {
int[] array = {11,2,31,4,25};
//输出全部的数组元素
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
System.out.println("===============");
//计算所有元素的和
int sum=0;
for (int i = 0; i < array.length; i++) {
sum += array[i];
}
System.out.println("sum="+sum);
System.out.println("===============");
//查找最大元素
int maxm = array[0];
for (int i = 1; i < array.length; i++) {
maxm=maxm>array[i]?maxm:array[i];
}
System.out.println("maxm="+maxm);
System.out.println("===============");
}
}
增强for循环 & 数组作方法入参 & 数组作返回值：
public class Demo04 {
public static void main(String[] args) {
int[] array = {11,2,31,4,25};
//计算所有元素的和
int sum = 0;
for (int i : array) {
sum += i;
}
System.out.println("sum="+sum);
System.out.println("============");
//反转数组
int[] reverse = reverse(array);
print(array);
print(reverse);
}
//输出全部的数组元素
public static void print(int[] array){
for (int i : array) {
System.out.print(i+"\t");
}
System.out.println();
System.out.println("============");
}
//反转数组
public static int[] reverse(int[] array){
int[] result = new int[array.length];
for (int i = 0,j = result.length-1; i < array.length; i++,j--){
result[j]=array[i];
}
return result;
}
}
多维数组
多维数组即是数组的数组，如二维数组本质上是一个特殊的一维数组，其的每一个元素都是一个一维数组。
- 二维数组
//int a[][] = new int[2][5];
//int[][] array = {{1,2},{3,4},{5,6}};
public class Demo {
public static void main(String[] args) {
int[][] array = {{1,2,3},{3,4,5},{5,6,7}};
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array[i].length; j++) {
System.out.print(array[i][j]+"\t");
}
System.out.println();
}
}
}
应用
Arrays类
public class Demo {
public static void main(String[] args) {
int[] a = {1,5,3,9,7};
System.out.println(a);//[I@14ae5a5 得到hashcode
//打印数组元素
System.out.println(Arrays.toString(a)); //Arrays.toString()输出数组
//顺序输出数组
Arrays.sort(a); //Arrays.sort()递增排序
System.out.println(Arrays.toString(a)); //Arrays.toString()输出数组
System.out.println(Arrays.binarySearch(a,5));
Arrays.fill(a,2,4,0); //左闭右开
System.out.println(Arrays.toString(a));
}
}
- Arrays.fill()：给数组赋值
- Arrays.sort()：对数组排序（升序）
- Arrays.equals()：比较数组
- Arrays.binarySearch()：查找数组元素
冒泡排序
public class Demo {
public static void main(String[] args) {
int[] a = {12,4,8,35,6};
for (int i = a.length-1; i > 0; i--) {
for (int j = 0; j < i; j++) {
if (a[j] > a[j+1]){
int m = a[j];
a[j] = a[j+1];
a[j+1] = m;
}
}
}
System.out.println(Arrays.toString(a));
}
}
冒泡排序为嵌套循环，算法的时间复杂度为O(n^2)。
稀疏数组
当数组中大部分元素为0*(同一个值)*时，可以使用稀疏数组来保存该数组。
稀疏矩阵的处理方式：
- 记录数组的行列，以及不同值
- 将具有不同值的元素和行列及值记录在一个小规模的数组中，从而减小程序的规模
扫一扫
155
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
