【JavaSE P1~P147】2023-10不熟悉的点，复习（1常用快捷写法， 2不太熟的概念，3数组内存图，4对象，5ArrayList 集合，6字符串，7静态static关键字）

1 常用快捷写法

shift + F6 批量替换变量名
Alt +insert 打开Generate，快速生成构造器和Getter,Setter
Alt + Enter 对已经用的类，自动导包
fori + enter 快速生成循环

array.fori 快速生成循环遍历数组array

自动生成接收返回值的变量： 对于调用有返回值的方法，alt + enter选local那一项，修改变量名enter确定


同理：list.fori 快速生成遍历ArrayList的for循环（ArrayList list）

java中输出换行的6种写法

public class LineBreak {
    public static void main(String[] args) {
        System.out.print("不换行");
        System.out.print("第一种换行方式\n");
        System.out.print("第二种换行方式"+"\n");

        System.out.printf("%s","不换行");
        System.out.printf("%s\n","第三种" );
        System.out.printf("%s%n","第四种");
        System.out.printf("%s","第五种"+"\n");

        System.out.println("第六种");
    }
}

不换行第一种换行方式
第二种换行方式
不换行第三种
第四种
第五种
第六种

2 不太熟的概念

进制

• HEX 16进制 DEC 10进制 OCT 进制 BIN 2进制

命名规则

 * 标识符硬命名规则：
  1.可用26个英文字母大小写  0-9 $ _
  2.不能以数字开头
  3.不能是关键字
 * 软规则：
  1.类名，大驼峰
  2.变量名，方法名，小驼峰

基本数据类型极其计算

• float 和 long 赋值时后跟F或L,最好大写因为l与1容易混淆

• 不同数据类型的运算注意点：
  数据范围和字节数不一定相关，float 4字节，long 8字节。但flaot 使用科学计数法
  自动类型转化，是数据范围从小到大
  强制类型转化，是数据范围从大到小，可能会精度损失，或者数据溢出
  ❤byte/short/char类型数据在计算时会自动提升为int，所以接收方必须是int或将结果强转
  取模只针对整数，其他取模没意义
  ❤运算当中有不同类型的数据，结果将会是数据类型范围大的那种
  ❤对于String类型数据+为链接，后续加到的都为字符串
  除非用小括号优先级最高，会先加再链接
  例如：

System.out.println(50 + 70 + "str"+ 30 + 70);//120str3070
System.out.println("eat" + (40 + 50));//eat90

• ❤注意复合赋值运算符隐含了一个强制类型转化
• byte += 6;//是正确写法，相当于byte + int 要运算所以byte提升为int，运算包括加减乘除，取模。相当于 int + int = int ,直接写byte = 6 + byte 错。

• 数据类型的默认赋值：
  整型 0
  浮点型0.0
  字符型 ‘\u0000’
  布尔型 false
  引用型 null

逻辑运算符

• 逻辑运算符 && || 短路，即左边条件若能判断结果就不运行右边条件
• 逻辑与或可连续比较多个条件 A && B && C ,< > 不可以 连续写，只能比较两个
• ❤三元运算符 ？：；结果必须被使用

编译器优化

• ❤byte/char/short 赋值时若右侧全为常量，如果右侧比较小，会隐含的补上一个强转。 如果右侧值超过，则报错

• switch case 匹配到哪一个case就从哪一个位置向下执行，直到遇到break或整体结束

• 三种循环里，若条件从未满足，do -while 至少会执行一次

• 在IDEA中，delete一个Module，外部打开project打开还是存在的，怎么导入一个外部保存的Module
  file-project structure + import module setup sdk即可

• 方法的三种调用形式，单独调，打印调，赋值调。void类型只能单独调

• 一个方法中可以有多个return，但必须保证同时只走一个return

• ❤重载： 多个方法的名称一样，但参数列表不一样
  与参数名称无关，与返回值类型无关

数组3种初始化方式

• 动态初始化（指定长度）、静态初始化（指定内容）、省略式静态初始化
  静态初始化可以省略写，但不可分为两步写。另外两个可以分为两步写

		int[] array1 = new int[3];
        int[] array11;
        array11 = new int[4];

        int[] array2 = new int[]{3,4,5};
        int[] array22;
        array22 = new int[]{3,4,5};
        
        int[] array3 ={1,2,3};

• 打印数组的方法 Arrays.toString(arr) 格式：[1,2,3]
• 光定义没有new就是没初始化
• 数组一旦创建，程序运行期间，长度不可改变
• String也是，不会改变，属于常量，如果改变一定是引用改变了指向的地址
• 数组作为参数和返回值都是传递地址

3 数组内存图

• ❤方法的运行要进栈，存放局部变量，方法的参数，或者是方法{}内部的变量。局部变量不赋值无法使用，没有默认值
• 凡是new出来的东西，都在堆当中，堆内存中的东西都有一个地址值，16进制，都有默认值
• 方法区：存储.class信息，包含方法的信息。

1. 定义数组并赋值时的内存图

 int[] arr = new int[3];//只规定长度，动态初始化
        System.out.println(arr);
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
        arr[1] = 10;
        arr[2] = 20;
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);

2.两个引用指向同一个数组

 //两个引用指向同一个数组的内存图
        int[] arr2 = new int[]{1, 2, 3, 4};
        System.out.println(arr2[0]);
        System.out.println(arr2[1]);
        System.out.println(arr2[2]);
        System.out.println(arr2[3]);

        int[] arr3 = arr2;
        System.out.println(arr3[0]);
        System.out.println(arr3[1]);
        System.out.println(arr3[2]);
        System.out.println(arr3[3]);

• 数组一旦创建，运行期间不可改变。

int[] arrC = new int[3];
arrC = new int[5];//长度改变
//等于创建了一个新的数组

4 对象

面向过程：需要实现一个功能的时候，详细处理每一个细节
面向对象：找一个已经具有该功能的人，来帮我做事

• 成员变量是直接定义在类当中的，在方法外边

• 对象的创建及使用
  1.导包，import 包名称.类名称对于和当前类属于同一个包的情况，省略导包语句不写。注意：使用同一个包下类中的静态方法时，要导包import static 包名称.类名称.方法名或*所有方法
  2.创建，格式： 类名称 对象名 = new 类名称();
  3.使用，对象名.成员变量名，对象名.成员方法名

对象内存图

• 一个手机类及其测试练习

public class Phone {
    public String brand;
    public double price;
    public String color;

    public Phone() {
    }

    public Phone(String brand, double price, String color) {
        this.brand = brand;
        this.price = price;
        this.color = color;
    }
    
    //成员方法
    public void call(String who){
        System.out.println("给"+who+"打电话");
    }
    public void sendMessage(){
        System.out.println("发信息");
    }
}

public class Demo01PhoneOne {
    public static void main(String[] args) {
        Phone one = new Phone();
        one.brand = "苹果";
        one.price = 8799.0;
        one.call("小明");
        one.sendMessage();
        System.out.println(one.brand);
        System.out.println(one.price);
        System.out.println(one.color);
    }
}

运行结果：

给小明打电话
发信息
苹果
8799.0
null

• 两个对象使用同一个方法
  根据调用方法的顺序，依次压栈运行方法，栈中后调用的方法在main方法之上（main方法没运行完，所以还在栈中）。若方法体运行完毕则出栈
  可见两对象调用同一个方法时，不产生任何联系，
  要产生联系：两个对象名称（对象的引用名）指向同一个对象（对象空间），即one和two指向的地址相同，相当于一个对象两个名称。
  

• 使用对象作为方法的参数或返回值同理
  传递的都是对象的地址，每次new一个对象都在堆中，栈中运行方法要赋值或用到对象，就赋值为该对象空间的地址，根据地址访问到对象空间进行使用。

  Getter/Setter快捷写法

• Code -> Generate或者alt + Insert

• Generate -> Constructor 为构造器
  -> Getter 方法
  -> Setter 方法

无参构造选 select none，全参构造 ctrl多选所有参数

• Getter同理，生成哪个成员变量的方法选哪个变量。Ctrl多选

this 关键字

• 当方法的局部变量和累的 成员变量重名时，“就近原则”优先使用局部变量
• 要访问本类当中成员变量，用 this.成员变量名
• 通过谁调用的方法，谁就是this

构造方法

是专门用来创造对象的方法，当用new来创建对象时，就是在调用构造方法
格式：

public 类名称（参数类型  参数名称）{
	方法体
}

1.构造方法的名称必须和所在类名完全一样
2.构造方法不要写返回值类型，void都不写
3.不能return一个具体的返回值，可以return;表结束
4.如果没写任何构造方法，编译器会默认送一个构造方法，没有参数，方法体什么都不做
5.一旦编写了至少一个构造方法，那么编译器将不再送这个默认无参构造。
6.构造方法可重载

JavaBean的四个标准

1. 所有成员变量都要使用private修饰
2. 编写一个无参数的构造方法
3. 写一个全参构造器，一个无参构造器
4. 每一个成员都要写一对getter,setter

对于基础类型boolean写getter方法需要写为isXxx，其他都写为getXxx，setter统一写setXxx

API 概述和使用

使用一个类：
1.导包：package语句后 import 包路径.类名称 class语句前，若要用的目标类和当前类位于同一个包下，省略导包。java.lang包下的内容不需要导包，其他的包都需要import语句。
2.创建：类名称 对象名 = new 类名称()；
3.使用：对象名.成员方法名()；

Scanner类

导包 import java.util.Scanner;

String next​() 查找并返回此扫描仪的下一个完整令牌。
int nextInt​() 将输入的下一个标记扫描为 int 。

public class Demo01Scanner {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("输入一个int给sc");
        int num = sc.nextInt();
        System.out.println("输入一个String给num");
        String str = sc.next();
        System.out.println("输出接收的sc,num");
        System.out.println(num + "," + str);

    }
}

练习一：输入两个int数字，并且求出和值

public class Exercise01InputSum {
    public static void main(String[] args) {
       inputSum();

    }
    public static int inputSum(){
        Scanner sc = new Scanner(System.in);
        System.out.println("输入两个整数");
        int num1 = sc.nextInt();
        int num2 = sc.nextInt();

        System.out.println("总和" + num1 + num2);
        return num1 + num2;
    }
}

练习二，输入三个数，求max先判断前2个哪个大，再把最大的跟第3个比较

public class Exercise02InputMax {
    public static void main(String[] args) {
        inputMax();
    }
    public static double inputMax(){
        System.out.println("输入3个整数");
        Scanner sc = new Scanner(System.in);
        double num1 = sc.nextDouble();
        double num2 = sc.nextDouble();
        double num3 = sc.nextDouble();
        double max = num1 < num2 ? num2 : num1;
        max = max < num3 ? num3 : max;
        System.out.println("max:" + max);
        return max;

    }

}

匿名对象

匿名对象只能使用唯一的一次，下次再用不得不再创建一个新对象

public class Demo1Anonymous {
    public static void main(String[] args) {
        Person one = new Person();
        one.name = "芭比";
        new Person().name = "肯";
        
        one.showName();//我叫null
        new Person().showName();//我叫芭比
    }
}

• 匿名对象做参数和返回值

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

        //用匿名对象简化写法
        methodParam(new Scanner(System.in));
    }
    public static void methodParam(Scanner sc){
        String str = sc.next();
        System.out.println(str);
    }
}

public class Demo2ParamReturn {
    public static void main(String[] args) {
        Scanner sc = methodReturn();
        sc.next();
    }
public static Scanner methodReturn(){
//        Scanner sc = new Scanner(System.in);
//        return sc;

        //简化写法
        return new Scanner(System.in);
    }
}

Random生成随机数

导包 import java.util.Random;

protected int next​(int bits) 生成下一个伪随机数。
int nextInt​(int bound) 返回伪随机的，均匀分布 int值介于0（含）和指定值（不包括），从该随机数生成器的序列绘制。

对象数组

array[1].getName(); 写法正确，根据数组用到对象的方法✔

5 ArrayList 集合

• 数组的长度不可以发生改变，ArrayList 集合的长度可以随意变化
• ArrayList中指泛型
  泛型：装在集合当中的所有元素， 全都是统一的类型
  注意：泛型只能是引用类型，不能是基本类型
• jdk 1.7开始，右侧的尖括号内部可以不写内容，但<>本身还是要写
  ArrayList list = new ArrayList<>();右侧可以不写泛型内容，但左侧一定要写，这个算是标准写法
• 对于ArrayList直接打印的不是地址值，而是[内容]，为空则[]，一般为[元素1,元素2,元素3,元素4]
• ArrayList打印

public static void main(String[] args) {
        ArrayList<String> list1 = new ArrayList<>();
        list1.add("哈哈");
        list1.add("呵呵");
        System.out.println(list1);//[哈哈, 呵呵]
        
    }

• ArrayList常用方法和遍历

public boolean add(E e)向集合中添加元素，参数类型和泛型一致；返回值boolean代表是否添加成功
public E remove(int index)根据索引删除，返回删除的元素。（索引从0开始）
public int size()获取长度，返回值是集合中包含的元素个数
public E get​(int index) 返回此列表中指定位置的元素。
list.fori 快速生成遍历循环

• 因为泛型只能是引用类型，不能是基本类型，因为集合存的是地址。所以基本来兴对应使用“包装类”
• 引用类型都位于java.lang包下，所以无需导包

基本类型	包装类
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

从JDK1.5开始，支持自动装箱，自动拆箱
自动装箱：基础类型->包装类
自动拆箱：包装类->基础类型

集合练习题1：生成6个1~33之间的随机整数，添加到集合，并遍历

public class Exercise1List {
    public static void main(String[] args) {
        for (int n = 0; n < 1000; n++) {//测试100次
            Random r = new Random();
            ArrayList<Integer> list = new ArrayList<>();
            for (int i = 0; i < 6; i++) {
                int num = r.nextInt(33) + 1;
                list.add(num);
                
            }
            System.out.println(list);

        }
    }
}

集合练习题2：自定义4个学生对象，添加到集合，并遍历

public class Exercise2List {
    public static void main(String[] args) {
        Student stu1 = new Student("barbie",true,"研二");
        Student stu2 = new Student("ken",false,"大一");
        Student stu3 = new Student("小明",true,"一年级");
        Student stu4 = new Student("小李",false,"幼儿园");

        ArrayList<Student> list = new ArrayList<>();
        list.add(stu1);
        list.add(stu2);
        list.add(stu3);
        list.add(stu4);
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i).name);
        }
    }

集合练习题3 ：按指定格式遍历集合字符串即ArrayList

• 定义以指定格式打印集合的方法(ArrayList类型作为参数）使用{}扩起集合，使用@分隔元素，
• 格式参照{元素1@元素2@元素3@元素4}

public class Exercise03List {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("一");
        list.add("二");
        list.add("三");

        printArray(list);

    }
    public static void printArray(ArrayList<String> list){
        System.out.print("{");
        for (int i = 0; i < list.size(); i++) {
            if(i == list.size() - 1){
                System.out.print(list.get(i));
            }else{
                System.out.print(list.get(i) + "@");
            }
        }
        System.out.println("}");
    }
}

集合练习题4：筛选集合中的随机数

• 用一个大集合存入20个随机数字，然后筛选其中的偶数，
• 放到小集合当中。要求使用自定义的方法来实现筛选，集合当返回值

public class Exercise04List {
    public static void main(String[] args) {
        System.out.println(evenNumber(20));
    }

    //参数：确定传入大集合的随机数个数
    public static ArrayList<Integer> evenNumber(int size){
        ArrayList<Integer> maxList = new ArrayList<>();
        for (int i = 0; i < size; i++) {
            Random r = new Random();
            maxList.add(r.nextInt());
        }
        System.out.println(maxList);

        ArrayList<Integer> minList = new ArrayList<>();
        for (int i = 0; i < maxList.size(); i++) {
            if(maxList.get(i) % 2 == 0){
                minList.add(maxList.get(i));
            }
        }
        return minList;
    }

}

6 字符串

在java.lang包下，所以不用导包。
程序中所有的双引号字符串，都是String类的对象（就算没有new也是）
字符串的特点：
1.内容永不可变
2.因为字符串内容不可变，所以可以共享
3.字符串效果上相当于是char[]字符数组，但是底层原理是byte[]字节数组

字符串的3+1种构造方法

• 1public String();创建一个空白字符串， 不含有任何内容
• 2public String(char[] array);根据字符数组的内容，来创建对应的字符串
• 3public String(byte[] array);根据字节数组的内筒，来创建对应的字符串
• 1种直接创建
  String str = "Hello";注意：直接写上双引号，就是字符串对象。只要是字符串一定是对象

字符串的常量池

public boolean equalsIgnoreCase(String str);//忽略大小写进行内容比较

equals和==

• ==
  对于基本数据类型比较 内容
  对于引用类，只有是同一个对象才true（比较的是对象的内存地址）
• equals
  只能比较引用对象，普通类对象，只有同为同一个对象才是true
  但对于File,String,Data和包装类，是比较内容

public class Demo2ConstantPools {
    public static void main(String[] args) {
        String str1 = "abc";
        String str2 = "abc";
        char[] charArray = {'a', 'b', 'c'};
        String str3 = new String(charArray);

        System.out.println(str1 == str2);//true
        System.out.println(str2 == str3);//false

    }
}

程序当中直接写上的双引号字符串，就在字符串常量池中。
即直接创建的字符串在常量池，若内容相同即为共享一个对象，3种构造方法的字符串不在常量池也不是共享，是由字符数组或字节数组在堆中转化为字节数组的地址，内容相同也不是同一个对象。

public class Demo2ConstantPools {
    public static void main(String[] args) {
        String str1 = "abc";
        String str2 = "abc";
        
        char[] charArray = {'a', 'b', 'c'};
        String str3 = new String(charArray);

        byte[] byteArray = { 'a', 'b', 'c'};
        String str4 = new String(byteArray);

        byte[] b2 ={'a', 'b', 'c'};
        String str5 = new String(b2);

        System.out.println(str1 == str2);//true
        System.out.println(str2 == str3);//false
        System.out.println(str3 == str4);//false
        System.out.println(str4 == str5);//false
        System.out.println(str1.equals(str2));//true
        System.out.println(str2.equals(str3));//true
        System.out.println(str3.equals(str4));//true
        System.out.println(str4.equals(str5));//true
        
        System.out.println(str1.equalsIgnoreCase("ABC"));//true
    
    }
}

字符串的获取相关方法

public int length();字符个数
public String concat(String);将当前字符串和参数拼接返回
public char charAt(int index);获取指定索引位置的单个字符（从0开始）
public int indexOf(String str);查出参数字符串在本字符串中首次出现的索引位置，没有就return -1；

注意：concat方法只会把拼接的结果返回，并不改变调用方法的字符串。除非原字符串接收他的返回值

字符串的截取方法

public String substring(int index);截取从参数位置一直到字符串末尾。返回新字符串
public String substring(int begin, int end);截取从begin开始一直到end结束中间的字符串。（按照索引从0开始对应 每一个字符，截取为 [begin,end)）

字符串的转换相关方法

public char[] toCharArray();将当前字符串拆分为字符数组作为返回值
public byte[] getByte();获得当前字符串底层的字节数组
public String replace(CharSequence oldString, CharSequence newString); 将所有出现的老字符替换成为新的字符串，返回替换后的新字符串（CharSequence简单理解为可以接受String类型）

字符串的分割方法

public String[] split(String regex);按照参数的规则将字符串切分成为若干部分
注意: 无法根据.划分做参数，split方法的参数其实是一个正则表达式，如果按照英文句“.”必须写“\\.”

public class Demo3StringMethod {
    public static void main(String[] args) {
        //字符串的获取相关方法-------------------------------------------------------
        String str1 = "Hi~Barbie";
        System.out.println(str1.length());
        System.out.println(str1.concat("Hi~Ken"));
        System.out.println("索引3的字符" + str1.charAt(3));
        str1 = str1.concat("bie~hello java $ rusty lake is fate 1 larua is blossom");
        System.out.println("str1 : " + str1);
        System.out.println("第一次出现bie的索引位置：" + str1.indexOf("bie"));
        //字符串的截取方法
        System.out.println("从4截取" + str1.substring(4));
        System.out.println("从[7,13)截取" + str1.substring(7,13));
        //字符串的转换相关方法
        char[] ch = str1.toCharArray();
        System.out.println("char数组：" + ch);
        System.out.println(Arrays.toString(ch));

        byte[] by = str1.getBytes();
        System.out.println("by数组：" + by + Arrays.toString(by));
        for (int i = 0; i < by.length; i++) {
            System.out.print(by[i] + ",");
        }
        System.out.println();

        String str2 = "Hoow doo yoou doo?";
        System.out.println("str2" + str2);
        System.out.println(str2.replace("oo", "*"));

        //字符串的分割方法
        String[] str3 = str1.split("a");
        System.out.println("根据a划分str1："+ str1);
        for (int i = 0; i < str3.length; i++) {
            System.out.println(str3[i]);
        }
        

    }
}

字符串练习

package qxcto.day24.demo1;

/**
 * Created with IntelliJ IDEA.
 *
 * @Author: 雪雪子
 * @Date: 2023/10/03/18:24
 * @Description: 定义一个数组，把数组{1,2,3}按照指定格式拼接成一个字符串。
 * 格式:[word1#word2#word3]
 *
 * 思路：先把数组转化为字符串String,但注意分隔需要加逗号到字符串，再用split替换为#
 * 此处默认为字符串数组
 */
public class Exercise01String {
    public static void main(String[] args) {
        String[] strArr = {"hello", "甄嬛", "流朱", "barbie"};
        System.out.println(fromArrayToString(strArr));
    }
    public static String fromArrayToString(String[] array){
        String str = "[";

        for (int i = 0; i < array.length; i++) {
            if(i == array.length - 1){
                str += array[i];
            }else{
                str += array[i] + "#";
            }
        }
        str += "]";
        return str;
    }
}

package qxcto.day24.demo1;

import java.util.Scanner;

/**
 * Created with IntelliJ IDEA.
 *
 * @Author: 雪雪子
 * @Date: 2023/10/03/18:45
 * @Description: 统计输入的字符串中各种字符的个数，键盘输入一个字符串，
 * 并且统计其中各种字符出现的次数。种类有：大写字母、小写字母、数字、其他。
 */
public class Exercise02String {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入任意字符串");
        String str = sc.next();

        int[] count = countChar(str);
        System.out.println("str:" + str);
        System.out.println("数字个数:" + count[0] + " 大写字母:" +
                count[1] + " 小写字母:" + count[2] + " 其他:" + count[3]);
    }
    public static int[] countChar(String str){
        char[] ch = str.toCharArray();
        //计数器count
        int[] count = new int[4];//4种,分别统计为数字，大写字母，小写字母，其他
        for (int i = 0; i < ch.length; i++) {
            if(ch[i] >= 48 && ch[i] <= 57){
                count[0]++;
            }else if(ch[i] >= 65 && ch[i] <= 90){
                count[1]++;
            }else if(ch[i] >= 97 && ch[i] <= 122){
                count[2]++;
            }else{
                count[3]++;
            }
        }
        return count;
    }
}

7 静态static关键字

用于多个对象共享同一份数据的情况，例如，一个学生类Student，除过姓名成绩等不同的属性外，共同的属性应该为同一间教室，多个对象的教室属性，内容完全相同。无需作为对象成员变量，每次赋不同的值。只需赋值一次，多个对象共享即可。
一旦用了static关键字，那么这样的内容不在属于对象自己，而是属于类的，所以凡是本类的对象，都共享一份static变量或方法。

例如：定义学生类中学号为static，作用：每new一个学生对象，学号都自增统计学生数量

public class DemoStatic {
    public static void main(String[] args) {
        Student stu1 = new Student("barbie",true,18);
        Student stu2 = new Student();
        Student stu3 = new Student("奥罗拉",true,16);
        Student stu4 = new Student("菲利普",false, 17);
        stu3.showInfo();
        stu2.showInfo();
        stu4.showInfo();
    }
}

学生学号：3 姓名：奥罗拉 是否女孩：true 年龄：16
学生学号：2 姓名：null 是否女孩：false 年龄：0
学生学号：4 姓名：菲利普 是否女孩：false 年龄：17

静态方法不属于对象，而是属于类。如果没有static关键字，那么必须首先创建对象，然后通过对象才能使用他。

MyClass obj = new MyClass();
        obj.method();

        obj.methodStatic();//不推荐，会误以为是普通成员方法
        MyClass.methodStatic();

对于静态方法来说，可以通过对象名进行调用，也可以直接通过类名称来调用
不推荐用对象调用静态方法，因为会误以为是普通成员方法，且编译后也会被javac翻译成为类名称,.静态方法名
有static，都推荐使用类名称进行调用。
对于本类当中的静态方法，可以省略类名称直接调用。
注意：1.静态不能直接访问非静态
2. 静态方法当中不能用this
因为在内存当中是先有得静态内容，后有的非静态内容。
this代表当前对象，通过谁调用的方法 ，谁就是当前对象。但静态方法不用对象

静态static的内存图

静态方法就算写为对象.方法，对象.属性。编译期间也会翻译为类.方法或类.属性，然后去方法区找。跟对象无关

public class Student {
    //为什么定义两个，因为id属于学生的属性，属于对象，每个对象不一样。但idCount属于属于类
    //每次new该类对象才自增，不保存加过的数
    private static int idCount = 0;
    private int id = 0;
    static String room = "一年级一班";
    String name;
    boolean girl;
    int age;

    public Student(String name, boolean girl, int age) {
        this.id = ++idCount;
        this.name = name;
        this.girl = girl;
        this.age = age;
    }
    public Student(){
        this.id = ++idCount;
    }
    public void showInfo(){
        System.out.println("学生学号：" + this.id + " 姓名：" + this.name + " 是否女孩：" + this.girl + " 年龄：" + this.age);
    }

    public static void setRoom(String room) {
        Student.room = room;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setGirl(boolean girl) {
        this.girl = girl;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public static int getIdCount() {
        return idCount;
    }

    public int getId() {
        return id;
    }

    public static String getRoom() {
        return room;
    }

    public String getName() {
        return name;
    }

    public boolean isGirl() {
        return girl;
    }

    public int getAge() {
        return age;
    }

}

public class Demo02Static {
    public static void main(String[] args) {
        Student.room = "大一一班";

        Student one = new Student("小刘", false, 20);
        System.out.println("one的姓名：" + one.getName());
        System.out.println("one的教室：" + Student.getRoom());
        System.out.println("one的年龄：" + one.getAge());
        System.out.println("one的学号：" + one.getId());
        System.out.println("============================");
        Student two = new Student("小李", true, 12);
        System.out.println("two的姓名：" + two.getName());
        System.out.println("two的教室：" + Student.getRoom());
        System.out.println("two的年龄：" + two.getAge());
        System.out.println("two的学号：" + two.getId());

        System.out.println("学生人数：" + Student.getIdCount());

    }

}

注意：根据类名称访问静态成员变量的时候，全程和对象没关系，只和类有关

静态代码块

特点：当第一次用到本类时，静态代码块执行唯一的一次。
静态内容总是优先于非静态，所以静态代码块比构造方法先执行
格式：

public class 类名称{
	static{
  		//静态代码块的内容
	}
}

静态代码块的典型用途：用来一次性地对静态成员变量进行赋值