2021/12/27 Java学习
1.IDE项目
main()方法：快捷键psvn；
输出语句：sout
查看运行框显示：Alt+4
重要：代码修复：Alt+回车
删除光标所在行：ctrl+Y
重复当前行：ctrl+D
重要：格式化代码行：ctrl+Alt+L
单行注释：ctrl+/ （取消再按一次）
多行注释：ctrl+Shift+/ （取消再按一次）
自动生成代码、toString，get，set方法：Alt+Ins
移动当前代码行：Alt+Shift+上下箭头
一、方法：
for循环次数快捷见：循环次数.fori ; eg:5.fori
package ln.javatest.day04.demo02;
public class Demo01Method {
public static void main(String[] args) {
printMethod();
}
public static void printMethod() {
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 5; j++) {
System.out.println("*");
}
System.out.println();
}
}
}
方法的定义和调用：
package ln.javatest.day04.demo02;
public class Demo02MethodDefine {
public static void main(String[] args) {
//单独调用：方法名称（参数）
sum(10,20);
System.out.println("================");
//打印调用：System.out.println(方法名称（参数）)
System.out.println(sum(10,20));
System.out.println("================");
//赋值调用: 数据类型 变量名称 = 方法名称（参数）
int number = sum(10,27);
System.out.println(number);
}
public static int sum(int a ,int b){
System.out.println("方法执行啦！");
int result = a + b;
return result;
}
}
对比有参数和无参数方法：
package ln.javatest.day04.demo02;
public class Deno03MethodParam {
public static void main(String[] args) {
method1(2,9);
method2();
}
//两个数字相乘，做乘法，必须知道两个数字各自是多少，否则无法进行计算
//有参数
public static void method1(int a, int b){
int result = a * b;
System.out.println("结果是：" + result);
}
//打印输出固定10次文本字符串
public static void method2(){
for (int i = 0; i < 10; i++) {
System.out.println("Hello!" + i);
}
}
}
对比有返回值和无返回值方法：
package ln.javatest.day04.demo02;
public class Demo04MethodReturn {
public static void main(String[] args) {
//我调用你，你告诉我结果
int num = getSum(10,20);
System.out.println("返回值是:"+ num);
//我调用你，你不用告诉我结果
printSum(10,20);
}
public static int getSum(int a ,int b){
int result = a + b;
return result;
}
public static void printSum(int a , int b ){
int result = a + b;
System.out.println("结果为：" + result);
}
}
方法练习题：
package ln.javatest.day04.Demo03;
public class Demo01MethodSame {
public static void main(String[] args) {
methodSame(20,20);
}
public static void methodSame(int a ,int b){
if(a == b){
System.out.println("这两个数相同！");
} else{
System.out.println("这两个数不相同！");
}
}
}
package ln.javatest.day04.Demo03;
public class Demo02MethodSum {
public static void main(String[] args) {
System.out.println(getSum());
}
public static int getSum(){
int sum = 0;
for (int i = 0; i <= 100; i++) {
sum += i;
}
return sum;
}
}
package ln.javatest.day04.Demo03;
public class Demo03MethodPrint {
public static void main(String[] args) {
printCount(3);
}
public static void printCount(int a ){
for (int i = 1; i <= a; i++) {
System.out.println("Hello" + i);
}
}
}
方法的注意事项：
1.方法应该定义在类当中，但是不能再方法当中再定义方法，不能嵌套。
2.方法定义的前后顺序无所谓
3.方法定义之后不会执行，如果希望执行，一定要调用：单独调用、打印调用、赋值调用。
4.如果方法有返回值，那么必须写上“return 返回值；”，不能没有。
5.return后面的返回值数据必须和方法的返回值类型对应一致。
6.对于一个void没有返回值的方法，不能写return后面的返回值，只能写“return；”
7.“return；”可省略不写
8.一个方法当中可以有多个return语句，但是必须保证同时只有一个会被执行到。例如if-else里各有，但只有一个会被执行，两个return不能连写。
方法重载：
package ln.javatest.day04.Demo04;
public class Demo01MethodOverload {
public static void main(String[] args) {
System.out.println(sum(10,20));
System.out.println(sum(10,20,30));
System.out.println(sum(10,20,30,40));
}
public static int sum(int a ,int b){
return a + b;
}
public static int sum(int a ,int b,int c){
return a + b + c;
}
public static int sum(int a ,int b,int c, int d){
return a + b + c + d;
}
}
方法的注意事项： 方法重载与下列因素相关：
1.参数个数不同
2.参数类型不同
3.参数的多类型顺序不同
方法重载与下列因素无关：
1.与参数名称无关 eg.int a,int b; 和 int x, int y；一样
2.与方法的返回值无关
方法重载练习题：
package ln.javatest.day04.Demo04;
public class Demo02MethodOverloadSame {
public static void main(String[] args) {
if(isSame((byte)2,(byte)2)){
System.out.println("这两个数一样！");
} else{
System.out.println("这两个数不一样！");
}
if(isSame((short)176,(short)138)){
System.out.println("这两个数一样！");
} else{
System.out.println("这两个数不一样！");
}
if(isSame((int)36769,(int)47907)){
System.out.println("这两个数一样！");
} else{
System.out.println("这两个数不一样！");
}
if(isSame(5.7F,8.9F)){
System.out.println("这两个数一样！");
} else{
System.out.println("这两个数不一样！");
}
}
public static boolean isSame(byte a, byte b){
System.out.println("这是两个byte值。");
return a == b;
}
public static boolean isSame(short a, short b){
System.out.println("这是两个short值。");
return a == b;
}
public static boolean isSame(int a, int b){
System.out.println("这是两个int值。");
return a == b;
}
public static boolean isSame(float a, float b){
System.out.println("这是两个float值。");
return a == b;
}
}
package ln.javatest.day04.Demo04;
//实现重载的println方法
//byte short int long float double char boolean
//String
//在调用输出语句的时候，println方法其实就是进行了多种数据类型的重载形式。
public class Demo04OverloadPrint {
public static void main(String[] args) {
myPrint(100); //int
myPrint((byte)100); //byte
myPrint("hello"); //String
}
public static void myPrint(byte num){
System.out.println("num");
}
public static void myPrint(short num){
System.out.println("num");
}
public static void myPrint(int num){
System.out.println("num");
}
public static void myPrint(long num){
System.out.println("num");
}
public static void myPrint(float num){
System.out.println("num");
}
public static void myPrint(double num){
System.out.println("num");
}
public static void myPrint(char zifu){
System.out.println("zifu");
}
public static void myPrint(boolean is){
System.out.println("num");
}
public static void myPrint(String str){
System.out.println("num");
}
}
package ln.javatest.day04.Demo05;
public class Demo01Array {
public static void main(String[] args) {
//动态初始化数组
//创建一个数组，里面可以存放300个数字
//格式：数据类型[] 数组名称 = new 数据类型[数组长度]；
int[] arrayA = new int[300];
//创建一个数组，能存放10个double类型的数据
double[] arrayB = new double[10];
}
}
2.静态初始化数组 1)静态初始化的基本格式
package ln.javatest.day04.Demo05;
public class Demo02Array {
public static void main(String[] args) {
//直接创建一个数组，里面装的全都是int数组，具体为：5,15,25
int[] arrayA = new int[]{5,15,25};
//创建一个数组，用在装字符串，“Hello“，”World“，”Java“
String[] arrayB = new String[]{"Hello","World","Java"};
}
}
2）静态初始化的省略格式
package ln.javatest.day04.Demo05;
public class Demo03Array {
public static void main(String[] args) {
//省略格式的静态初始化
int[] array = {10,20,30};
//静态初始化标准格式可以拆分成为两个步骤
int[] arrayB;
arrayB = new int[]{10,20,30};
//动态初始化也可以拆分成两个步骤
int[] arrayC;
arrayC = new int[5];
//静态初始化一旦使用省略格式，就不能拆分成为两个步骤了
//int[] arrayD;
//arrayD = {10,20,30};
//上面两句是错误的写法
}
}
3）静态数组的 *** 作：访问数组元素进行获取。
package ln.javatest.day04.Demo05;
public class Demo04ArrayUse {
public static void main(String[] args) {
//静态初始化的省略格式
int[] array = {10,20,30};
//直接打印数组名称，得到的是数组对应的，内存地址哈希值。
System.out.println(array); //[I@75412c2f
System.out.println(array[0]); //10
System.out.println(array[1]); //20
System.out.println(array[2]); //30
//也可以将数组当中的某一个单个元素，赋值交给一个变量
int num = array[1]; //num=20
System.out.println(num); //20
}
}
4）对动态数组的 *** 作：对数组元素进行赋值。
package ln.javatest.day04.Demo05;
public class Demo05ArrayUse {
public static void main(String[] args) {
//动态初始化一个数组
int[] array = new int[3];
System.out.println(array); //内存地址值
System.out.println(array[0]); //0
System.out.println(array[1]); //0
System.out.println(array[2]); //0
//将数据123赋值给交给数组array当中的1号元素。
array[1] = 123;
System.out.println(array[0]); //0
System.out.println(array[1]); //123
System.out.println(array[2]); //0
}
}
三、Java中的内存划分：分为5个部分。
1.栈（Stack)：存放的都是方法中的局部变量。方法运行一定要在栈中。
局部变量：方法的参数，或者是方法{}内部的变量；
作用域：一旦超出作用域，立刻从栈内存当中消失；
2.堆（Heap): 凡是new出来的东西，都在堆当中。
堆内存里面的东西都有一个地址值：16进制； 堆内存里面的数据，都有默认值。
规则：
如果是整数 默认为0
如果是浮点数 默认为0.0 如果是字符 默认为'u0000'
如果是布尔 默认为false
如果是引用类型 默认为null
3.方法区（Method Area): 存储.class相关信息，包含方法的信息。
4.本地方法栈（Native Method Stack）：与 *** 作系统相关。
5.寄存器（pc Register): 与CPU有关。
四、数组索引越界异常
package ln.javatest.day04.Demo05;
public class Demo01ArrayIndex {
public static void main(String[] args) {
int[] array = {12,25,35};
System.out.println(array[0]); //15
System.out.println(array[1]); //25
System.out.println(array[2]); //35
//错误写法：并不存在3号元素，所以数组索引越界异常 System.out.println(array[3]);
}
}
五、空指针异常
package ln.javatest.day04.Demo05;
public class Demo02ArrayNull {
public static void main(String[] args) {
int[] array = null;
array = new int[3];
System.out.println(array[0]);
}
}
六、获取数组的长度以及数组大小的改变
package ln.javatest.day04.Demo05;
public class Demo03ArrayLength {
public static void main(String[] args) {
int[] arrayA = new int[3];
int[] arrayB = {10,20,30,3,4,5,6,7,8,9};
int len = arrayB.length;
System.out.println(len); //10
//数组一旦创建，程序运行期间，长度不可改变。
//两个new是两个数组，开辟的两个不同大小的空间，arrayC只是一个名字
int[] arrayC = new int[3];
System.out.println(arrayC.length); //3
arrayC = new int[5];
System.out.println(arrayC.length); //5
}
}
七、数组的遍历输出
package ln.javatest.day04.Demo05;
public class Demo04Array {
public static void main(String[] args) {
int[] array = {15,25,30,40,50};
//原始方式一个个打印
System.out.println(array[0]);
System.out.println(array[1]);
System.out.println(array[2]);
System.out.println(array[3]);
System.out.println(array[4]);
//使用循环，次数其实就是数组的长度
for(int i = 0;i < 5;i++){
System.out.println(array[i]);
}
//数组长度不确定时
//数组名称.fori:可自动生成。 eg.array.fori
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
}
}
八、求出数组的最值
package ln.javatest.day04.Demo05;
//求数组中的最大值
public class Demo05ArrayMax {
public static void main(String[] args) {
int[] array = {15,30,50,70,100};
int max = array[0];
for (int i = 1; i < array.length; i++) {
if(max < array[i]){
max = array[i+1];
}
}
System.out.println(max);
}
}
九、数组元素反转
package ln.javatest.day04.Demo05;
public class Demo07ArrayReverse {
public static void main(String[] args) {
int[] array = {15,30,50,70,100,90};
for (int j = 0; j < array.length; j++) {
System.out.print(array[j]+",");
}
System.out.println();
for (int min = 0,max = array.length-1; min < max;min++,max--) {
int x;
x = array[min];
array[min] = array[max];
array[max] = x;
}
for (int j = 0; j < array.length; j++) {
System.out.print(array[j]+",");
}
}
}
十、数组作为方法参数
package ln.javatest.day04.Demo05;
//数组作为方法参数
public class Demo09ArrayParam {
public static void main(String[] args) {
int[] array = {10,20,30,40,50};
arrayPrint(array);
}
public static void arrayPrint(int[] a){
for (int i = 0; i < a.length; i++) {
System.out.print(a[i]+",");
}
}
}
十一、数组作为方法的返回值
package ln.javatest.day04.Demo05;
public class Demo08ArrayReturn {
public static void main(String[] args) {
int[] array1 = calculate(3,3,3);
System.out.println("总和："+array1[0]);
System.out.println("平均数："+array1[1]);
}
public static int[] calculate(int a, int b, int c){
int sum = a + b + c ;
int avg = sum / 3;
int[] array = new int[2];
array[0] = sum;
array[1] = avg;
return array;
}
}
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）