java学习笔记

JAVA学习（ 重难点）

1.JAVA定义数据，可以添加下划线方便阅读数据
public static void main(String[] args) {
int int_num = 1_00_00_0;
System.out.println(“int num:” + int_num);

    long long_num = 1_00000;
    System.out.println("long num:" + long_num);

    float float_num = 2.10_001F;
    System.out.println("float num:" + float_num);

    double double_num = 2.10_12_1;
    System.out.println("double num:" + double_num);
}

}

int num:100000
long num:100000
float num:2.10001
double num:2.10121
可读性增强

java的基本数据结构和变量数据类型
因为java是面向对象的语言，一个程序的基本单位就是class
public是访问修饰符，不写public也能正确编译，但是这个类无法从命令行执行

变量
没有规定变量的初始值，默认变量值为零
java的基本数据类型
整数类型 ：byte（一字节），short（二），int（四），long（八）
浮点数类型：float（四），double（八）
字符类型 ：char（二）
布尔类型： boolean（true）（false）
计算机储存的最小单元是字节，一个字节是一个八位的二进制数，8个bit
可以为了辨识添加下划线：int i=2_000_000（不会影响数的值）
浮点数类型：
对于float，需要加上f后缀（float f=3.14e34f,科学计数法表示的3.14×10的34次方）

字符类型：
使用单引号‘’，要与字符串的“”区分
除了上述类型其余都是引用类型，最常见的就是String

定义变量时，在变量前加final变量就成为了常量（作用是更改避免不必要的多余更改）

var关键词：
省略变量类型{
StringBuilder（var） sb=new StringBuilder();
可以使用var代替StringBuilder，系统会自动检测
}

浮点数运算
浮点数常常无法精确表示
两个浮点数比较，通常是判断两个浮点数的差小于一个极小数
java中的自动类型转换

正向过程：
由低字节到高字节自动转换
byte——short——int——long——float——double
逆向过程：
使用强制转换，可能丢失精度
布尔运算
（特别解释）短路运算：
表达式的值可以提前确定结果
三元运算符：b?x:y
字符和字符串
要显示一个字符的Unicodde编码，只需要将char类型直接赋值给int
//int n1=‘中’；
转义字符加Unicode编码来表示一个字符
//char c4=’\u4e2d’；（注意是十六进制）
字符串：
双引号；
借助转义字符表示\等不易表示的字符
可以使用+来连接任意字符串和其它数据类型
若用加号连接字符串和其他数据类型会将其它数据类型先转为字符串，再连接
字符串可以使用“““…”””表示多行字符
字符串拥有不可变特性：
执行String s=“Hello”;
虚拟机先创建Hello，然后用s指向他
执行 s=“World”；
虚拟机先创建字符串，然后变量s访问他
字符串“Hello”依然存在，只是s不指向他了
空值null
区分空值null和空字符串“”，空字符串是一个有效的字符串对象，他不等于null

数组类型：

特点：
数组所有元素初始化为默认值，都为零，但精度不一样
数组一旦创建，大小不可变
访问数组的某个元素，使用索引
可以在定义数组时直接指定初始化元素，数组自动监测数组大小

 /* public class Javashuzu {
    public static void main(String[] args) {
		String names[]= {"abc","vde","dfd"};
		 String s=names[1];
		names[1]="mes";
		System.out.println(s);
	}
}  */   字符串的不可变性

输入和输出

输入：Scanner scanner=new Scanner(System.in);
读取一行输入并获取字符串：
String name=scanner.nextLine();
读取一行输入并获取整数：
int a= scanner.nextInt();
使用Scanner需要通过import导入java.util.Scanner;

占位符 说明
%d 格式化输出整数
%x 格式化输出十六进制整数
%f 格式化输出浮点数
%e 格式化输出科学计数法表示的浮点数
%s 格式化字符串

break和continue 语句应用于for 和while
continue提前结束这次循环

for each 循环遍历数组
！！遍历数组：

 for each:
    int []ns={1,2,3,4};
  for(int n:ns)
    System.out.println(n);
  

打印数组内容：
直接打印打印的是数组在JVM中的地址
可以采用for each 打印数组内容
也可以利用Arrays.toString（）

数组排序：

```java
//冒泡排序
public class Main {
    public static void main(String[] args) {
        int[] ns = { 28, 12, 89, 73, 65, 18, 96, 50, 8, 36 };
        // 排序前:
        System.out.println(Arrays.toString(ns));
        for (int i = 0; i < ns.length - 1; i++) {
            for (int j = 0; j < ns.length - i - 1; j++) {
                if (ns[j] > ns[j+1]) {
                    // 交换ns[j]和ns[j+1]:
                    int tmp = ns[j];
                    ns[j] = ns[j+1];
                    ns[j+1] = tmp;
                }
            }
        }
        // 排序后:
        System.out.println(Arrays.toString(ns));
    }

//每次循环，最大一位将被交换至末尾
*
java 标准库的排序函数：Arrays.sort()//由小到大
必须注意，对数组排序实际上修改了数组本身。例如，排序前的数组是：

int[] ns = { 9, 3, 6, 5 };
在内存中，这个整型数组表示如下：

  ┌───┬───┬───┬───┐

ns───>│ 9 │ 3 │ 6 │ 5 │
└───┴───┴───┴───┘
当我们调用Arrays.sort(ns);后，这个整型数组在内存中变为：

  ┌───┬───┬───┬───┐

ns───>│ 3 │ 5 │ 6 │ 9 │
└───┴───┴───┴───┘
即变量ns指向的数组内容已经被改变了。

如果对一个字符串数组进行排序，例如：

String[] ns = { “banana”, “apple”, “pear” };
排序前，这个数组在内存中表示如下：

               ┌──────────────────────────────────┐
           ┌───┼──────────────────────┐           │
           │   │                      ▼           ▼
     ┌───┬─┴─┬─┴─┬───┬────────┬───┬───────┬───┬──────┬───┐

ns ─────>│░░░│░░░│░░░│ │"banana"│ │"apple"│ │"pear"│ │
└─┬─┴───┴───┴───┴────────┴───┴───────┴───┴──────┴───┘
│ ▲
└─────────────────┘
调用Arrays.sort(ns);排序后（按首字母排序），这个数组在内存中表示如下：

               ┌──────────────────────────────────┐
           ┌───┼──────────┐                       │
           │   │          ▼                       ▼
     ┌───┬─┴─┬─┴─┬───┬────────┬───┬───────┬───┬──────┬───┐

ns ─────>│░░░│░░░│░░░│ │"banana"│ │"apple"│ │"pear"│ │
└─┬─┴───┴───┴───┴────────┴───┴───────┴───┴──────┴───┘
│ ▲
└──────────────────────────────┘
原来的3个字符串在内存中均没有任何变化，但是ns数组的每个元素指向变化了

多维数组：
要打印一个二维数组，可以使用两层嵌套的for循环
package 实验;

  public class Javashuzu {
    public static void main(String[] args) {
		 int[]ss= {1,2,3};
		 for(int n:ss)
		System.out.println(n);
		  int[][]ns= {
				  {1,2,3},
				  {2,5},
				  {1,8,6}			  
		  };
		  for(int[]arr:ns) {//打印二维数组
			  for(int n:arr) {
				  System.out.print(n);
				  System.out.println();
			  }
		  }
	}
}

命令行参数：

java命令通过启动Java运行时环境，加载指定的类并调用该类的main方法来启动一个Java应用程序
指定的class需要声明一个main方法，格式如下:

public static void main(String[] args)

原文链接：https://blog.csdn.net/future234/article/details/80856002

   **面向对象的基本概念，包括：**

类

实例

方法

面向对象的实现方式，包括：

继承

{
向上转型，向下转型，instanceof

多态

Java语言本身提供的机制，包括：

package

classpath

jar

以及Java标准库提供的核心类，包括：

字符串

包装类型

JavaBean

枚举

常用工具类

[**类**]

第一列指示类本身是否有权访问由访问级别定义的成员。正如你可以看到， 一个类总是有权访问它自己的成员。
第二列指示与该类（ 不管其父级） 相同的包中的类是否具有对成员的访问权限。
第三列指示在此包外部声明的该类的子类是否有权访问成员。
第四列指示是否所有类都具有对成员的访问权限。

[**多态**]

多态定义