Java基础-基本语句语法-方法-数组-内存分配及栈和堆的区别

Java基础-基本语句语法-方法-数组-内存分配及栈和堆的区别

最近一段比较忙，抽出时间，来更一篇。 这一篇主要还是Java基础， 基础语句语法、 数组、内存分配及栈和堆的区别。

1. Java基本语句结构

• 1.1 语句结构种类

  • 顺序结构
  • 选择结构
  • 循环结构

• 1.2 顺序结构

  • 从上到下依次执行

• 1.3 选择结构【可以嵌套】

  • if ， if else ， if else if …… else
  • switch case【支持byte，short，char，int，String】

• 1.4 循环结构

• for

  for(初始化语句;判断条件语句;控制条件语句) {
           循环体语句;
  }
  第一步：先执行初始化语句，只执行一次
  第二步：执行判断条件语句
  第三部：执行循环体语句
  第四步：执行控制条件语句，然后再执行循环体语句【循环】
  

• while

  初始化语句;
  while(判断条件语句) {
      循环体语句;
      控制条件语句;
  }
  

• do while

  do {
          循环体语句;
  }while((判断条件语句);
  

2.Java方法

2.1 定义

• 方法就是完成特定功能的代码块
  • 1：系统方法，只需要会使用，不需要知道内部的结构
  • 2：自定义方法：方法的内部实现需要我们来写
  • 3：方法内部不能再嵌套方法

2.2 格式

• 方法格式

  修饰符   返回值类型   方法名(参数类型 参数 , ……){
       函数体
       return 返回值
  }
  

• 修饰符: public static或直接是public或是其它 private

• 返回类型:所有的数据类型（基本类型：int ,char ,float, long, 引用类型:String）

• 方法名：1:见名知意 2: getMax

• 参数类型:所有的数据类型 ，如果一个方法没有返回值，则返回值类型为void

• 参数名:变量名

• 返回值：就是要返回的结果（这个结果必须和返回类型一致）

3. 变量的使用范围

3.1. 方法范围

看一段代码：

publiic class xxx{

public static void main(String args）{
    
    int num1 = 10;
    
    int num2 = 15;
    
    for(int i = 0; i< 10; i ++){
        
        System.out.println("i: "+ i);
        System.out.println("num1+num2"+(num1+num2));
    }
    
   /// 这句话 是编译不过的 说明了 int 类型 变量名 为i的 这个变量的使用范围只有在for 循环内， 超出范围 ， 便引用不到了。
   /// System.out.println("i: "+ i);
    
    System.out.println("num1-num2:"+ (num1-num2));
    
}
}

看上边的这个例子，为什么 num1, 和num2 的使用范围 为什么可以在for 循环内呢，
因为 for 循环也属于方法的一部分， 而 num1 num2 是属于方法范围的访问范围， 也就是说 在整个方法内都可访问。

3.2. 类范围

再看一段代码：

public class test{
    private int p ;
    private String str;
    private boolean b;
    
    public static void main(String args[]){
        
        System.out.println("p: "+ p  + " str: "+str + " b: "+b);
        p = 10;
        str = "sssss";
        b = true;
        
        System.out.println("after : p: "+ p  + " str: "+str + " b: "+b);
    }
    
}

类范围的变量， 如果不初始化则为变量的默认值， int 为0 ， string 为 null , boolean 为 false
修改的结果为 10 ， ssss， true
使用的访问范围 就是 类内。

3.3. 方法块

再来看一个

public class xxx{
    
    private static  Map<String,String> params = new HashMap<String,String>();
    static {
        
        params.put("a","A");
        params.put("b","B");
        params.put("c","C");
        params.put("d","D");
        
    }
    
    public static void main(String args[]){
        
        for(Map.Entry<String,String> entry: params.entrySet()){
            
            System.out.println("key: "+entry.getKey() + " value: "+ entry.getValue());
        }
    }
    
}

静态方法块是在类实例初始化之前 ， 也就是类加载的时候初始化的， 这样就可以保证在调用之前 有了赋值。

3.4. 常量与静态变量

我们知道C/C++ 中的常量修饰符 是const ,
Java 中的常量修饰符是final
静态变量 、静态方法、 静态类 关键字是static
看个代码：

public class xxx{

 public final String name = "rose";
 /  这里的声明顺序 可以final 或者static 在前边 
 public final static name2 = "jack";
 
 public static void main(String args[]){
    
    System.out.print("rose + jack "+ (rose +"&"+ jack)); 
     
 }   
    
}

3.5. 静态方法和非静态方法

• 静态方法属于类所有,类实例化前即可使用;

• 非静态方法可以访问类中的任何成员,静态方法只能访问类中的静态成员;

• 因为静态方法在类实例化前就可以使用,而类中的非静态变量必须在实例化之后才能分配内存;

在使用上面，静态方法中只能调用静态成员或者方法，不能调用非静态方法或者非静态成员，而非静态方法既可以调用静态成员或者方法又可以调用其他的非静态成员或者方法。
再来个例子

class xxx {
	public int sum(int a,int b){//非静态方法
	  return a+b;
	}
	public static void main(String[] args){
		int  result=sum(1,2);//静态方法调用非静态方法
	    System.out.println("result="+result);
	}
}

这样编译就会出错， 怎么办，
静态方法可以调用静态方法， 把sum 改成静态方法

class xxx{
	public static int sum(int a,int b){//加入static关键字，变成静态方法
	  return a+b;
	}
	public static void main(String[] args){
		int  result=sum(1,2);//静态方法调用静态方法
	    System.out.println("result="+result);
	}
}

要么， 这样， 实例化类对象， 调用

class xxx{
	public int sum(int a,int b){
	  return a+b;
	}
	public static void main(String[] args){
		Test test=new Test();//实例化类
		int  result=test.sum(1,2);//调用非静态方法
	    System.out.println("result="+result);
	}
}

4.Java访问控制符

上边说了Java方法的基本格式与声明方法， 这里说一下Java中的访问修饰符， 不多， 就两步，一起来看一下。

4.1.访问控制符有哪些

• Java有四种访问控制级别：public、protected、private和friendly（即不加修饰符，默认访问级别为包访问级别 ）

4.2.类访问控制符

• 类访问控制修饰符包括：public或默认访问级别
  • 使用public访问控制修饰符使得类变为公有的，没有使用访问控制修饰符的类则具有默认的访问级别
  • 公有类在任何地方都是可见的
  • 默认访问级别的类只能由属于同一个包中的类使用

4.3.类成员访问控制符

• 类成员（方法、字段、构造方法等）可以具备四种访问控制级别之一
  • public使得类成员成为公有的
  • protected使得类成员成为受保护的
  • private使得类成员成为私有的
  • 没有使用访问控制修饰符的话，类成员将会拥有默认的访问级别
• 具体如下所示

  访问级别	从其他包中的类来访问	从同一包中的其他类来访问	从同一个类
  public	可以	可以	可以
  private	不可以	不可以	可以
  protected	若是子类，直接调用则可以。若非子类，也不可以	可以	可以
  default	不可以	可以	可以

• 注意：
  • protected修饰的话，若是子类，直接调用则可以，声明对象后再调用则不可以

5.数组

5.1 数组概念

• 数组是一个容器，可以存储多个变量，这些变量数据类型要一致
• 数组既可以存储基本数据类型，也可以存储引用数据类型

5.2 一维数组

数组定义格式
* 格式1：数据类型【】 数组名
* 格式2：数据类型 数组名【】
int[] a； 定义了一个int类型的数组a； int a[]; 定义了一个int类型的a数组； 推荐使用第一种定义方式。

数组的初始化
* Java中的数组必须先初始化,然后才能使用。
* 所谓初始化：就是为数组中的数组元素分配内存空间，并为每个数组元素赋值。

初始化分类：
* a:动态初始化: 只指定长度，由系统给出初始化值
* b:静态初始化: 给出初始化值，由系统决定长度
* 注意事项：这两种方式，只能使用一种，不能进行动静结合

5.3 二维数组

数组定义格式

• 数据类型[][] 变量名 = new 数据类型[m][n];

• m表示这个二维数组有多少个一维数组

• n表示每一个一维数组的元素个数

  举例:

    int[][] arr = new int[3][2];
    定义了一个二维数组arr
    这个二维数组有3个一维数组，名称是arr[0],arr[1],arr[2]
    每个一维数组有2个元素，可以通过arr[m][n]来获取,表示获取第m+1个一维数组的第n+1个元素

6.Java的内存分配以及栈和堆的区别

6.1 先了解几个概念

• 栈
• 堆
• 方法区
• 本地方法去
• 寄存器

A:栈: 存放的是局部变量
局部变量：在方法定义或者方法声明上的变量都是局部变量。
B:堆: 存放的是所有new出来的东西
特点：
    a: 每一个new出来的东西都会为其分配一个地制值。
    b: 每一个变量都有一个默认的值
        byte，short，int，long  -- 0
        float，double            -- 0.0
        char                    -- '\u0000'
        boolean                -- false
        引用数据类型               -- null       
    c: 使用完毕就变成了垃圾，等待垃圾回收器对其回收
C:方法区:(面向对象部分讲解)
D:本地方法区:(和系统相关)
E:寄存器:(cpu使用)

7.总结

主要就是一些Java中的基本基础知识， 如果想学好Java 就上手敲吧 ， 多试试，多看看 就会了， 我们下篇见