java笔记

南风北寒

已于 2022-02-22 15:39:49 修改

阅读量267

点赞数 1

文章标签： java 后端 eclipse

于 2022-02-12 12:48:21 首次发布

本文链接：https://blog.csdn.net/qq_44224579/article/details/122895073

版权

基本数据类型和引用数据类型的区别:

二维数组内存结构

二维数组笔试题

类的加载及对象的创建

方法参数机返回值传递(基本类型)

public class Test {

    public int changNum(int x) {//声明/定义一个x变量空间// 方法内部的临时变量
//        int x=1;//变量空间的值写死    这个值不是方法定义时有的 真正用它才告诉的
        System.out.println("方法执行开始：" + x);//1
        x = 10;
        System.out.println("方法执行最终：" + x);//10
        return x;//返回值 将x临时的变量空间内的值（值 引用）返回出来
    }

    //每一个类中不是必须包含主方法的
    //主方法不属于任何一个类--主方法属于虚拟机
    public static void main(String[] args) {
        //创建一个对象--前提：有一个类模型
        //加载类模板的过程
        Test t = new Test();//堆内存中开辟空间
        int a = 1;
        a = t.changNum(a);//需要一个int的条件 int x=a;//接收返回值后a是10 不接收a仍是1
        //调用方法    让方法执行一遍
        //1.方法存在哪里 堆内存的对象空间内
        //2.方法在哪里执行 栈内存中开辟一块临时的方法执行空间
        System.out.println("方法执行完毕，main方法中a的值：" + a);//方法没有返回值是1，有接收返回值是10
    }


}

public class Test {


    public void changeArray(int[] x){
        System.out.println("方法执行开始:"+x[0]);//1
        x[0] = 10;//修改数组x的第一个位置元素
        System.out.println("方法执行最终:"+x[0]);//10
    }

    //每一个类中不是必须包含主方法的
    //主方法不属于任何一个类--主方法属于虚拟机
    public static void main(String[] args){
        //0.加载类模板的过程
        Test t = new Test();
        int[] a = new int[]{1,2,3};
        t.changeArray(a);
        //方法存在堆内存的对象空间里 方法执行在栈内存中的临时空间
        //调用方法时将a的值传递给了x    int[] x = a;  传递过来的就是一个 引用
        System.out.println("方法执行完毕,main方法中a数组的第一个值:"+a[0]);//10
    }

}

形参和实参
   形参可以理解为是方法执行时的临时变量空间 x
   实参可以理解为是方法调用时传递进去的参数 a
   方法调用时会将实参的内容传递给形参
   如果内容是基本类型传递的是值形参改变实参不变
   如果内容是引用类型传递的是引用形参改变实参跟着改变

public class Demo {

    //设计一个方法  用来交换两个数组的元素
    //  方法本身是否需要参数及返回值   需要参数 提供两个数组  返回值 不要
    public int[][] changeTwoArray(int[] a,int[] b){
        //方式二  将两个数组的地址引用直接互换
        int[] temp = a;
        a = b;
        b = temp;
        int[][] result = {a,b};
        return result;
        //2.交换数组中的元素
        //方式一  将两个数组内的元素对应位置互换
        /*for(int i=0;i<a.length;i++){//每一次找到一个数组中的元素 跟另一个数组对应位置
            int x = a[i];
            a[i] = b[i];
            b[i] = x;
        }*/
        //方式一的设计问题在于
        // 用循环的方式挨个交换数组内的元素 性能比较慢
        // 交换的时候需要保证两个数组的长度是一致的

    }

public static void main(String[] args){
        //创建一个Demo对象
        Demo d = new Demo();
        //用来交换两个数组元素 a{1,2,3,4}  b{5,6,7,8}
        //1.先有两个数组
        int[] x = {1,2,3,4};
        int[] y = {5,6,7,8};
        //2.调用demo中的changeTwoArray方法
        int[][] value = d.changeTwoArray(x,y);
        x = value[0];
        y = value[1];
        //3.验证一下看一看
        for(int v:x){
            System.out.println(v);
        }
        System.out.println("-----------");
        for(int v:y){
            System.out.println(v);
        }
    }
}

public class TestFunctions {
    //*2.设计一个方法  用来交换一个数组(头尾互换)
    //是否需要参数？ 需要提供一个数组  及返回值？ 可以不需要返回值
    public int[] changeArrayElements(int[] array){
        //2.数组内部的元素头尾对应互换
        for(int i=0;i<array.length/2;i++){//0-5 1-4 2-3
            int temp = array[i];
            array[i] = array[array.length-1-i];
            array[array.length-1-i] = temp;
        }
        return array;
    }


}

public class Test {
    public static void main(String[] args) {

        //0.先创建一个对象
        TestFunctions tf =new TestFunctions();
        //1.有一个数组
        int[] x ={1,2,3,4,5,6};
        //2.利用tf对象调用方法执行操作
        int[] result = tf.changeArrayElements(x);
        //3.验证
        for(int v:result){
            System.out.println(v);
        }
    }
}

==================================

方法之间来回调用

写法允许（编译好用）执行可能会产生StackOverflowError 栈溢出错误

如下：

public class Person {
    public String name;
    public int age;
    public String sex;

    //无参构造方法

    public Person() {
        System.out.println("我是人类的无参构造方法");
    }
    public void eat(){
        this.sleep();//当前调用方法的对象
        System.out.println("这是人类的吃饭方法");
    }
    public void sleep(){
        this.eat();
        System.out.println("这是人类的睡觉方法");
    }



}

public class Test {
    public static void main(String[] args) {
        Person p =new Person();//调用人类的无参构造方法
        p.eat();
    }
}

Scanner读取问题

import java.awt.*;
import java.util.Scanner;

public class TestScanner {

    public static void main(String[] args) {
        //利用数组实现用户的登录
        //1.有小数组来充当数据库
        //2.用Scanner让用户输入
        Scanner input = new Scanner(System.in);
        //input这个小人在计算机中的消息队列内等着读取
        System.out.println("请输入密码");//(3)
        int password = input.nextInt();//阻塞效果//(4)
        //方式一：利用nextLine方法读取一个空回车符
        //input.nextInt();//""
        System.out.println("请输入账号：");//(1)
        String name = input.nextLine();//阻塞效果(2)//此时没有阻塞证明读取到东西了//""
    //方式二：利用next方法读取字符串  next方法读取方式与nextInt一样，不读取回车符
    //String name = input.next();    

        //3.比较
        System.out.println("接收到了账号名：" + name);
        System.out.println("我接收到了密码：" + password);
    }
}

方式一多了一行，方式二留了回车符
方式三(建议)：将账号和密码都统一用nextLine来读取
但密码password需要String---->int

数据类型转换前提：同种大数据类型一致基本-基本引用-引用基本<--包装类-->引用 int--Integer char--Character byte--Byte long--Long float--Float
int value = Integer.parseInt(password);

注意：若按方式三类在密码输入abc时（不是char类型不会转换97等数字）出现NumberFormatException "abc"无法转换数字

方法重写和方法重载的区别

public class Animal {

    public Animal(){
        System.out.println("这是Animal中的无参数构造方法");
    }

    protected void eat(){
        System.out.println("这是动物的吃饭方法");
    }

}

public class Person extends Animal{

    public Person(){
        System.out.println("这是Person中的无参数构造方法");
    }

    public void eat(){
        System.out.println("人类的吃饭方法，讲究色香味俱全");
    }
}

public class Test {
    public static void main(String[] args) {
        //加载类模板的过程
        //Person Animal Object
        //创建一个Person类型的对象
        Person p =new Person();//new调用了Person的无参数构造方法
        p.eat();
  
    }
}

输出结果为：

Animal中的无参数构造方法
Person中的无参数构造方法
人类的吃饭方法，讲究色香味俱全