Java小细节

细节1：方法调用，对象的创建都要在方法中实现

类里面只有属性与方法

相如方法调用，对象的创建都要在方法中实现。

public class Test {

    public static void showMap(Shape shape)
        //多态，接受的对象不一样，同种方法表现出来的形式不一样
    {
        shape.show();
    }

    public static void main(String[] args)
    {
       Shape shape1=new Cycle();
    Shape shape2=new React();
    showMap(shape1);//showMap(new Cycle());
    showMap(shape2);//showMap(new React());
    //两种写法都可以
    }
    
}

细节二：方法里面不可以再创建方法，但是可以调用其他方法。

//正确：
public class Test {
    public static void showShape(Shape shape)
    {
        shape.show();
    }
    public static void main(String[] args) {

        Shape shape1=new A();
        showShape (shape1 );

    }
   
}

//c
public void test()
{
    public void mm()
    {
        
    }
}

细节三：对象的引用是有作用域的

//这样写是正确的
public static void main(String[] args) {
        Scanner scanner=new Scanner(System .in);
        int a=scanner.nextInt() ;
        int b= scanner.nextInt();

//这样写是错误的
Scanner scanner=new Scanner(System .in);

public static void main(String[] args) {
        int a=scanner.nextInt() ;//会报错：没有scanner
        int b= scanner.nextInt();
/*
Scanner scanner=new Scanner(System.in);
相当于创建一个对象scanner
对象应该在方法里面创建，
对象的引用是有作用域的，scanner是有作用域的，因为scanner是个引用，他存储在栈上，而对象是存储在堆上；
对象创建在堆上，只要你保存了就不会销毁。
*/

import java.util.*;

interface ICompute
{
    int computer(int n,int m);
}

class Add implements ICompute
{
    @Override
    public int computer(int n, int m) {
        return m+n;
    }
}

class Sub implements  ICompute
{
    @Override
    public int computer(int n, int m) {
        return n-m;
    }
}

public class Main {

    public void func ()
    {
        Sub sub1=new Sub ();
    }

    public void funcs ()
    {
        Add add1=new Add();
        sub1.computer(10,20);//error  can not resolve symbol sub1
    }
    //对象的引用是有作用域的，sub1是有作用域的，因为s是个引用，他存储在栈上，而对象是存储在堆上；对象创建在堆上，只要你保存了就不会销毁。

}

细节四：java中数组的遍历有两种方式

//数组的遍历
    public static void main5(String[] args) {
        int[] arr = {1,2,3,4,5,6,7,8,9,10};
        //方法一 ：不用数组的下标，直接遍历打印
        for (int x:arr) {
            System.out.print(x + " ");
        }
        System.out.println();
        //方法二：fori
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }

细节五：数组的声明常用的有3种方式

public static void main4(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int[] array = {0};
        int[] arrs = new int[]{1};
        int[] arr = new int[n];//变长数组
        for (int i = 0; i < n; i++) {
            System.out.print(arr[i]);
        }
    }

细节六：Java 是不能获取栈上变量的地址的 ，只能获取堆上的地址

public static void main(String[] args) {
        int a = 10;
        int b = 20;
        //a b 都是局部变量 ，存储在栈上 ，Java 是不能获取栈上变量的地址的 ，只能获取堆上的地址。
        //局部变量存储在栈上 ， 成员变量存储在堆上。
        System.out.println(sum(a , b));
    }
    public static int sum(int a,int b){
        return a+b;
    }

细节七：递归的注意事项

1：递归的问题求解的思路：

我们遇到的问题直接并不好解决，但是发现将原问题拆分成其子问题之后，子问题与原问题有相同的解法，等子问题解决之
后，原问题就迎刃而解了。

2：递归问题一般别展开。

3：

执行语句结束之后再回来执行剩下的语句

还有就是 递的次数 == 归的次数

4：

栈帧的角度思考递归

细节八：多组输入注意

hasNextInt : 判断是否有下一个整数 ， 有的话继续执行。

. nextInt : 读入一个整数

细节九：方法的重载注意

public void sum (double a, double b){}

public void sum (double b,double a){}//顺序不一样也会构成重载

public int sum (int a,int b,double c){}
/*
以上的三种方法都可以构成重载
构成重载的条件： 方法名必须一样  参数列表必须不一样（顺序 ， 类型 ， 参数的个数 / 三者其一）
*/

原理是通过方法的标签来找所对应的方法