java 基础

 

关于标识符

标识符：指程序中，我们自己定义的内容，比如类的名字、方法名字和变量的名字等。

命令规则：硬性要求

• 可以包含英文字母（区分大小写）、0-9数字、$和_
• 不能以数字开头
• 不能是关键字

命令规范 软性建议

• 类名规范：首字母大写，后面每个单词首写字母大写
• 变量名规范：首字母小写，后面每个单词首字母大写
• 方法名规范：桶变量名

方法重载：

• 参数个数不同
• 参数类型不同
• 参数的类型顺序不同

 数组

标准格式：
数据类型[] 数组名称 = new 数据类型[] {元素1,元素2,...};
省略格式：
数据类型[] 数组名称 = {元素1,元素2,...};

 

/*
使用静态初始化数组的时候，格式还可以省略一下，
标准格式：
数据类型[] 数组名称=new 数据类型[]{元素1，元素2.。。};

省略格式：
数据类型[] 数组名称={元素1，元素2.。。};

注意事项：
1、静态初始化没有直接指定长度，但是仍然会自动推算得到长度。
2、静态初始化标准格式可以拆分成为两个步骤。
3、动态初始化也可以拆分成为两个步骤。
4、静态初始化一旦使用省略格式，就不能拆分成为两个步骤了。

使用建议：
如果不确定数组当中的具体内容，用动态初始化；否则，已经确定了具体的内容，用静态初始化。

直接打印数组名称，得到的是数组对应的内存地址哈希值。
访问数组的格式：数组名称[索引值]
索引值：就是一个int数字，代表数组当中元素的编号。
【注意】索引值从0开始，一直到“数组的长度-1”为止。

使用动态初始化数组的时候，其中的元素将会自动填充值，规则如下：
如果是整数类型，那么默认是0
如果是浮点类型，默认是0.0
如果是字符型，默认是'\u0000'
如果是布尔类型，默认是false
如果是引用类型，默认是null

注意事项：
静态初始化其实也有默认值的过程，只不过系统马上将默认值替换成了大括号中的具体数值。
 */
public class ArrayTest{
    public static void main(String[] args){
        //省略格式的静态初始化
        int[] arrayA = new int[] {5,6,7,8,29};

        //静态格式化的标准格式，可以拆分成两个步骤
        int[] arrayB;
        arrayB = new int[]{1,2,3};

        //动态初始化也可以拆分成两个步骤
        int[] arrayC;
        arrayC = new int[5];

        //静态初始化的省略格式，不能拆分成两个步骤
        // int[] arrayD;
        // arrayD = {1,2,3};

        System.out.println(arrayA);


        boolean[] array = new boolean[3];
        System.out.println(array[0]);

    }
}

 

一个数组 

两个不同数组

 

 指向同一个数组

 

一个对象

两个对象使用同一个方法的地址

 

两个对象指向相同地址

 对象类型作为方法的参数

 对象类型作为返回值

 

/**
 * 局部变量和成员变量
 * 1、定义的位置不一样【重点】
 * 局部变量：在方法内部
 * 成员变量：在方法的外部，直接写在类当中
 * 
 * 2、作用范围不一样【重点】
 * 局部变量：只有方法当中才可以使用，出了方法就不能使用
 * 成员变量：整个类全都可以使用
 * 
 * 3、默认值不一样【重点】
 * 局部变量：没有默认值
 * 成员变量：有默认值
 * 
 * 4、内存的位置不一样
 * 局部变量：位于栈内存
 * 成员变量：位于堆内存
 * 
 * 5、生命周期不一样
 * 局部变量：随着方法进栈而诞生，随着方法出栈而消失
 * 成员变量：随着对象创建而诞生，随着对象被垃圾回收而消失
 */
public class VariableDiff{
    String name;//成员变量

    public void methodA(){
        int num = 20;//局部变量
        System.out.println(num);
        System.out.println(name);
    }

    public void methodB(int param){//方法的参数是局部变量
        //参数在方法调用的时候，必须会被赋值的
        System.out.println(param);
    }
}

 封装：

/**
 * 面向对象三大特征：封装、继承、多态
 * 
 * 封装性在java当中的体现：
 * 1、方法就是一种封装
 * 2、关键字private也是一种封装
 * 
 * 封装就是将一些细节信息隐藏起来，对于外界不可见
 */

 public class Method{
     public static void main(String[] args){
         int[] array = {1,2,35,3,9};
         int max = getMax(array);
         System.out.println(max);
     }

     public static int getMax(int[] array){
         int max = array[0];
         for (int i = 0; i < array.length; i++) {
             if(array[i] > max){
                 max = array[i];
             }
         }
         return max;
     }
 }

 

/**
 * 
 * 一旦使用了private进行修饰，那么本类当中仍然可以随意访问。
 * 但是，超出了本类范围之外就不能再直接访问了。
 * 
 * 间接访问private成员变量，就是定义一对儿Getter/Setter方法
 * 
 * 必须叫setXxx或者getX命名规则。
 * 对于Getter来说，不能有参数，返回值类型和成员变量对应；
 * 对于Setter来说，不能有返回值，参数类型和成员变量对应。
 * 
 * 对于基本类型当中的boolean值，Getter方法一定要写成isXxx的形式，而setXxx规则不变。
 * 
 * 当方法的局部变量和类的成员变量重名的时候，根据“就近原则”，优先使用局部变量。
 * 如果需要访问本类当中的成员变量，那么使用格式：this.成员变量
 */

 public class Person{
     String name;//姓名
     private int age;//年龄
     private boolean male;

     public void show(){
         System.out.println("姓名："+name+",年龄："+age);
     }

     //参数name是对方的名字
     //成员变量name是自己的名字
     public void sayHelo(String name){
         System.out.println(name + ",你好，我是" + this.name);
     }
     public void setAge(int num){
         if(num <= 100 && num >0){
             age = num;
         }else{
            System.out.println("数据不对");
         }
     }

     public int getAge(){
         return age;
     }

     public void setMale(boolean b){
         male = b;
     }

     public boolean isMale(){
         return male;
     }
 }

 

一个标准的类通常由下面四个部分组成：
1、所有的成员变量都要使用private关键字修饰
2、为每一个成员变量编写一对Getter/Setter方法
3、编写一个全无参数的构造方法
4、编写一个全参数的构造方法
这个标准的类就叫Java Bean

 

Java jdk api中的Scanner使用

import java.util.Scanner;
/***
 * Scanner类的功能，可以实现键盘输入数据，到程序当中
 * 
 * 引用类型的一般步骤：
 * 
 * 1、导包
 * import 包路径.类名称；
 * 如果需要使用的目标类，和当前类位于同一个包下，则可以省略导包语句。
 * 只有java.lang包下面的内容不需要导包，其他的包都需要import语句
 * 
 * 2、创建
 * 类名称 对象名 = new 类名称();
 * 
 * 3、使用
 * 对象名.成员方法名()
 */

 public class ScannerTest{
     public static void main(String[] args){
        Scanner sc = new Scanner(System.in);

        System.out.println("请输入一个数字：");
        int num = sc.nextInt();
        System.out.println("输入的int数字是："+num);

        String str = sc.next();
        System.out.println("输入的字符是：" + str);

     }
 }

 匿名对象的使用：

import java.util.Scanner;
/**
 * 创建对象的标准格式：
 * 类名称 对象名 = new 类名称();
 * 
 * 匿名对象就是只有右边的对象，没有左边的名字和赋值运算符。
 * new 类名称();
 */
public class Anonymous{
    public static void main(String[] args){
        // //普通使用方式
        // Scanner sc = new Scanner(System.in);
        // int num = sc.nextInt();

        // System.out.println(num);

        // //匿名对象的方式
        // int num2 = new Scanner(System.in).nextInt();
        // System.out.println(num2);


        // //使用一般写法传入参数
        // Scanner sc = new Scanner(System.in);
        // methodParam(sc);

        // //使用匿名对象来进行传参
        // methodParam(new Scanner(System.in));

        Scanner sc = methodReturn();
        int num = sc.nextInt();
        System.out.println("输入的是：" + num);
    }

    public static void methodParam(Scanner sc){
        int num = sc.nextInt();
        System.out.println("输入的是："+ num);
    }

    public static Scanner methodReturn(){
        return new Scanner(System.in);
    }
}

 ArrayList基本使用

/**
 * 数组的长度不可以改变。
 * 但是ArrayList集合的长度是可以随意变化的。
 * 
 * 对于ArrayList来说，有一个尖括号<E>代表泛型。
 * 泛型：也就是装在集合中的所有的元算全部是同一种类型。
 * 注意：泛型只能是引用类型，不能是基本类型。
 * 
 * 注意事项：
 * 对于ArrayList集合来说，直接打印得到的不是地址值，而是内容。
 * 如果内容是空，得到的是空的中括号：[]
 * 
 * 如果希望向集合ArrayList当中存储基本类型数据，必须使用基本类型对应的“包装类”
 * 
 * 基本类型     包装类（引用类型包装类都位于java.lang包下）
 * byte         Byte
 * short        Short
 * int          Integer
 * long         Long
 * float        Float
 * double       Double
 * char         Character
 * boolean      Boolean
 * 
 * ArrayList的常用方法：
 * public boolean add(E e);向集合当中添加元素，参数的类型和泛型一致。返回值代表添加是否成功。
 * 备注：对于ArrayLit集合来说，add添加动作一定是成功的，所以返回值可用可不用
 * 但是对于其他集合的add，不一定成功
 * public E get(int index);从集合中获取元素，参数是索引编号，返回值是对应位置的元素。
 * public E remove(int index);从集合中删除元素，参数是索引编号，返回值是被删除的元素。
 * public int size();获取集合的尺寸长度，返回值是集合中包含的元素个数。
 */
import java.util.ArrayList;
public class DemoArrayList{
    public static void main(String[] args){
        //创建一个ArrayList集合
        //备注：从JDK1.7+开始，右侧的尖括号可以不写内容，但是，尖括号不能省略

        ArrayList<String> list = new ArrayList<>();
        //System.out.println(list);

        //向集合中添加数据
        list.add("张");
        list.add("我");
        System.out.println(list);

        list.add("一");
        String val = list.get(2);
        System.out.println(val);

        //从集合中删除
        String rm = list.remove(2);
        System.out.println(rm);

        System.out.println(list);

        int size = list.size();
        System.out.println(size);
    }
}