标签：i++ 局部变量 负数 加法 min 记录 for exce print
函数定义的格式：
修饰符 返回值的类型 函数名（形参列表）{
需要封装的功能代码；
}
修饰符：public static
返回值类型：函数执行完毕后，返回的结果的数据类型
函数名：函数名（），要符合变量名的命名规范
注意：有些函数是没有结果返回给调用者的，那么这个时候的返回值的类型是void
class demn{
public static void main(String[] args){
int num = add(2, 3);
System.out.println("结果：" + sum);
}
//做加法功能的函数
public static int add(int a, int b){
int a = 2;
int b = 3;
return a + b;
}
public static void add(int a, int b){
int sum = a + b;
System.out.println(sum);
}
public static int max(int a, int b){
int max = 0;
if(a > b){
max = a;
}else{
max = b;
}
return max;
}
//定义一个函数返回分数的等级
public static String getgrade(int score){
String grade = "";
if(score >= 90 && score <= 100){
grade = "A";
}else if(score >= 80 && score <= 90){
grade = "B";
}else{
grade = "C";
}
return grade;
}
}
class demn{
public static void main(String[] args){
}
public static void add(int a, int b){
System.out.println("总和" + (a + b));
return;
}
}
return关键字的作用：
1.返回数据给函数的调用者
2.函数一旦执行到return关键字，那么该函数结束
3.一个函数是void类型，那么也可以出现return关键字，但是return关键字后面不可以有任何数
函数的重载：在一个类中出现了两个或两个以上的同名函数，这个称为函数的重载
函数重载的作用：同一个函数名可以出现不同的函数，以应对不同个数或者不同数据类型的参数
函数重载的要求：
1.函数名一致
2.形参列表不一致（形式参数或者对应的数据类型不一致）
public static void add(int a, int b){
System.out.println("两个参数的总和" + (a + b));
}
public static void add(int a, int b, int c){
System.out.println("两个参数的总和" + (a + b + c));
}
public static void add(int a, int b, int c, int d){
System.out.println("两个参数的总和" + (a + b + c + d));
}
数组是同一种数据类型的容器
数组的定义格式：
? 数据类型[] 变量名 = new 数据类型[长度];
class demn{
int a = 10;
public static void main(String[] args){
//定义一个数组
int[] arr = new int[50];
arr[0] = 20;
arr[1] = 30;
arr[2] = 40;
arr[4] = 50;
System.out.println("hello world");
//等号将数组对象的内存地址赋予给arr变量
//查看数组中的所有数据
for(int index = 0; index < arr.length; index ++){
System.out.println(arr[index]);
}
}
}
栈内存的特点：
栈内存存放的都是局部变量，变量一旦出了自己的作用域，那么马上会重内存中消失，释放内存空间
堆内存的特点：
堆内存存储的都是对象数据（除了八中基本数据类型之外的数据），对象一旦被使用完，并不会马上从内存中消失，而是等待垃圾回收器，不定时把垃圾回收，这时候该对象消失，释放资源（凡是以new关键字创建的对象，jvm都会在堆内存中开辟一个新的空间，创建一个新的对象）
局部变量：
如果一个变量是在方法（函数）内部声明的，那么该变量就是一个局部变量
成员变量：
成员变量就是定义在方法之外，类之内的
class demn{
public static void main(){
//动态初始化
int[] arr = new int[2];
arr = null;//让该变量不要引用任何的对象，不要记录任何的内存地址
arr[1] = 10;
System.out.println(arr[1]);//报错，NullPointerException
}
}
数组中最常见的问题：
1.NullPointerException，空指针异常
原因：引用类型变量没有指向任何对象，而访问了对象的属性或者是调用了对象的方法
2.索引值越界
数组初始化的方式：
动态初始化：
数据类型 变量名 = new 数据类型[长度];
静态初始化：
数据类型[] 变量名 = {元素1， 元素2， ……}；
找一个数组中的最大值
class demn{
public static void main(String[] args){
int[] arr = new int[50];
int max = getmax(arr);
System.out.println(max);
}
public static int getmax(int[] arr)
{
int max = arr[0];
for(int i = 1; i < getmax.length; i++){
if(arr[i] > max){
max = arr[i];
}
}
return max;
}
}
排序算法
选择排序
public static void selectsort(int[] arr){
for(int j = 0; j < 4; j++){
for(int i = j; i < 4; i++){
if(arr[j] > arr[i]){
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
}
}
冒泡排序
public static void selectsort(int[] arr){
for(int i = 0; i < 3; i++){
for(int j = 0; j < 3 - i; j ++){
if(arr[j] > arr[j + 1]){
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
二分查找法
class demn{
public static void main(String[] args){
int[] arr = {12, 15, 19, 24, 53};//有序的数组才可以进行二分法查找
searchelement(arr, 34);
}
public static void searchelement(int[] arr, int target){
for(int i = 0; i < arr.length; i++){
if(arr[i] == target){
return i;
}
}
return -1;
}
public static void selectelement(int[] arr, int target){
int max = arr.length - 1;
int min = 0;
int mid = (max + min) / 2;
while(true){
if(target > arr[mid]){
min = mid + 1;
}else if(target < arr[mid]){
max = mid - 1;
}else{
return mid;
}
mid = (min + max) / 2;
if(max < min){
return -1;
}
}
}
}
数组工具类
import java.util.*;
class helloworld{
public static void main(String[] args){
int[] arr = {12, 3, 45, 5 ,23};
Arrays.sort(arr);
String info = Arrays.toString(arr);
System.out.println(info);
int index = Arrays.binarySearch(arr, 10);//如果能找到就返回该书的下标值，如果不能找到，就返回一个负数表示（
System.out.println(index);
}
}
二维数组的定义格式：
数据类型[][] 变量名 = new 数据类型[长度1][长度1];
二维数组的初始化方法：
动态初始化：
数据类型[][] 变量名 = new 数据类型[长度1][长度1];
静态初始化：
数据类型[][] 变量名 = {{元素1，元素2}， {……}， {……}};
数组的特点：
1.数组是智能存储同一种数据类型的数据
2.数组是会给存储到数组的元素分配一个索引值，索引值从零开始，最大的索引知识length-1
3.数组一旦初始化，长度固定
4.数组和数组之间的元素和元素之间的内存地址是连续
class demn{
public static void main(String[] args){
int[][] arr = new int[3][4];
arr[1][1] = 100;
System.out.println("二维数组的长度" + arr.length);//3
System.put.println(arr[1].length);
int[][] arr = {{1, 2, 4, 5}, {34, 55}, {354, 453}};
System.out.println(arr[2].length);
System.out.println(arr[1].length);
for(int i = 0; i < arr.length; i ++)
{
System.out.println(arr[i]);//输出的是三个内存地址
}
for(int i = 0; i < arr.length; i++){
for(int j = 0; j < arr[i].length; j ++){
System.out.println(arr[i][j]);
}
System.out.println();
}
}
}
标签：i++ 局部变量 负数 加法 min 记录 for exce print
原文地址：https://www.cnblogs.com/best-you-articles-040612/p/14773817.html
