从零开始学Java

Java基础

一、基本数据类型

数据类型	默认值	数据类型
byte	0	8位，有符号，以二进制补码表示
short	0	16位，有符号，以二进制补码表示
char	‘u0000’	一个单一的 16 位 Unicode 字符
int	0	32位，有符号，以二进制补码表示
long	0L	64位，有符号，以二进制补码表示
float	0.0f	32位，单精度
double	0.0d	64位，双精度

⭐小数的优先级一定大于整数

自动类型转换

符合规律：转换前的数据类型位数必须低于转换后的数据类型

​ 例如：16位的可以自动转换为32位的数据类型

public class conversion {
    
    
    public static void main(String[] args) {
    
    
        short a = 7;
        int b = a;
        System.out.println("short自动转换为int类型的结果为："+b);
    }
}

​ 运行结果：

强制类型转换

• 条件是转换的数据类型必须是兼容的。
• 格式：(类型)变量名
• 强制转换会造成内存溢出或者是精度问题

public class conversion {
    
    
    public static void main(String[] args) {
    
    
        double a = 4578;
        int b = (int) a;
        System.out.println("double数据类型强制转换为int类型，结果为："+b);
    }
}

​ 运行结果：

注意点：

• 不能使用布尔值（boolean）进行数据转换
• 不能把对象类型转换为不相干的类型
• 数字之间可以使用下划线进行分割

二、变量、常量、作用域

变量：所有变量在使用前必须声明

int a = 1;
type b = 2;

​ a，b都是变量

变量作用域

​ 局部变量：必须声明和初始化，并且只能在局部中调用

​ 实例变量：需要先定义变量再new，从属于对象。

public class Variable {
    
    
    // 这个实例变量对子类可见
    public String name;
    // 私有变量，仅在该类可见
    private double salary;
    //在构造器中对name赋值
    public Variable (String empName){
    
    
        name = empName;
    }
    //设定salary的值
    public void setSalary(double empSal){
    
    
        salary = empSal;
    }
    // 打印信息
    public void printEmp(){
    
    
        System.out.println("名字 : " + name );
        System.out.println("薪水 : " + salary);
    }

    public static void main(String[] args){
    
    
        Variable variable = new Variable("RUNOOB");
        variable.setSalary(1000.0);
        variable.printEmp();
    }
}

​ 类变量（静态变量）：独立于方法之外，用static修饰

public class Employee {
    
    
    private static int age;
    public static final String NAME = "wyf";
    public static void main(String[] args){
    
    
        age = 21;
        System.out.println(NAME+"的年龄："+age+"岁");
    }
}

运行结果：

常量：进行初始化，并且不能再改变数值

​ 格式：final 常量名=常量值；

​ 命名方式：使用大写字母以及下划线

三、运算符

算数运算符

+	-	*	/	%	++

 public static void main(String[] args){
    
    
        int a = 4;
        System.out.println(a);
        int b = a++;//执行完这行代码后，先给b赋值，再自增
        System.out.println(b);
        int c = ++a;//执行完这行代码后，再自增，先给c赋值，
        System.out.println(c);
 }

关系运算符

==	！=	>	<	>=	<=

逻辑运算符

&&	||	！
a && b	a || b	! (a && b)
两个为真，true	一个为真，true	为假，则为true

其他运算

幂运算

double pow = Math.pow(3, 1);
        System.out.println(pow);

短路运算

int d = 5;
boolean x =(c<4) && (c++<4);
System.out.println(x);
System.out.println(d);

​ 解释：当c<4为false时不会走c++<4，直接返回false，并且不会进行自增。

​ 字符串连接符：空字串 “”

三元运算符

//x ? y : z 
//如果x==true，则结果为y，否则为z  
	int score = 50;
    String type =score <80 ? "不及格":"及格";
    System.out.println(type);

 int max =a>b? a:b;
            max =max>c?max:c;
            System.out.println(max);

★ 运算符的优先级——括号

Java Doc

四、Scanner使用

获取输入的字符串：next()与nextLine()方法

Scanner scanner = new Scanner(System.in);
String str = scanner.next();
System.out.println(str);
scanner.close();

判断是否还有输入的数据：hasNext()与hasNextLine()

• next()不能得到带有空格的字符串

  Scanner scanner = new Scanner(System.in);
  int a = 0;
  float b =0.0f;
  System.out.println("请输入整数：");
  if (scanner.hasNextInt()){
        
        
      a = scanner.nextInt();
      System.out.println("您输入的整数为："+a);
      System.out.println("请输入小数：");
      if (scanner.hasNextFloat()){
        
        
          b = scanner.nextFloat();
          System.out.println("您输入的小数为："+b);
      }
      else{
        
        
          System.out.println("请输入小数！");
      }
  }
  else{
        
        
      System.out.println("请输入整数！");
  }
  scanner.close();
  

五、选择结构

​ equals：判断字符串是否相等，尽量减少==号进行字符串的比较

if语句当中至多一个else语句，在所有else if语句之后

​ ⭐获取邮箱@前面的字符串

    int index = email.indexOf("@");
    if (index == -1){
    
    
        return "邮箱格式错误！";
    }
    return email.substring(0,index);

switch多选择结构

**switch：匹配一个具体的值 ，case穿透：没有加break**

⭐获取手机号的尾数：

 //3.2获取手机号的尾数
    char c = tel.charAt(10);
    //3.2定义用来保存最终结果的变量price,初始值为0
    int price = 0;
    //3.3根据c字符的值，来为price重新赋值
    switch(c) {
    
    
        case '8': price=50; break;//尾数为8支付50
        case '4': price=0; break;//尾数为4免费
        default: price=20;//其他情况需支付20
    }

六、循环结构

while循环

	while(布尔表达式){
    
    
		//循环内容
	}

• 布尔表达式为true，程序会陷入死循环
• 1+2+3+…+100=？
• 不满足条件则不能进入循环

      	  int i = 0;
          int sum = 0;
          while(i<=100){
    
    
              sum = sum + i;
              i++;
          }
          System.out.println(sum);

do…while循环

• 至少循环一次

   int i = 0;
          int sum = 0;
         do {
        
        
             sum = sum + i;
             i++;
         }while (i<=100);
          System.out.println(sum);
  

while与do…while的区别：

• while先判断后执行，do…while是先执行后判断

• do…while总是保证循环体会被至少执行一次！

   int a = 0;
          while (a<0){
        
        
              System.out.println(a);
              a++;
          }
          System.out.println("==========================");
          do {
        
        
              System.out.println(a);
              a++;
          }while (a<0);
  

  输入结果：

for循环

结构体：

• for（初始化；布尔值；迭代）{
  //代码语句
  }

• for（声明语句：表达式）{
  ​ //代码语句
  }

for (int i = 0; i < 1000; i++) {
    
    
    int a =0 ;
    if (i % 5 == 0){
    
    
    System.out.print(i+"\t");//+"\t"可以实现i与i之间有空格
    }
    if (i%(5*3)==0){
    
    
    System.out.println();//每三个换一行
 }

使用for循环实现九九乘法表

for (int j = 1; j <= 9; j++) {
    
    
    for (int i = 1; i <=j; i++) {
    
    
    	System.out.print(j+"*"+i+"="+j*i +"\t");
    }
        System.out.println();
 }

• 打印第一列
• 固定的1再使用循环包起来
• 去掉重复项，i<=j
• 调整样式

七、方法

​ 执行功能：方法包含与类或对象当中

​ 解决一类问题的有序组合

​ 在程序中被调用，在其他地方引用

​ 命名规则：小写字母开头驼峰命名

​ 设计原则：原子性，即一个方法只完成1个功能，利于后期的扩展

方法类似于函数，包含一个方法头和方法

• 修饰符：可选，

• 返回值类型：void或其他返回值

• 方法名：实际名称，小写字母开头，驼峰结构

• 参数类型：占位符，可选，可以不包含任何参数

  • 形式参数：用来定义作用的，a跟b就是形式参数

    public static int add(int a,int b)
    

  • 实际参数：实际调用传递的参数，1跟2是实际参数

    int sum =add(1.2)
    

• 方法体：具体语句，定义该方法的功能

  return可以是返回也可以中止方法

方法的重载

​ 规则：方法名称必须相同

​ 参数列表必须不同（个数不同、类型不同、参数排序顺序不同等）

​ 返回类型可以相同也可以不相同

​ 仅是返回类型不同不足以成为方法的重载

可变参数-不定项参数

​ 在方法声明中，在指定参数类型加一个省略号（…），并且只能指定一个可变参数，必须位于方法参数的最后一个。

java只有值传递
args.length //数值长度

递归结构

• 头部：什么时候不调用自身方法，如果没有头，方法将陷入死循环
• 身体：什么时候需要调用自身方法
• 递归：n*f(n-1)

八、数组

基本特点

• 长度确定，不可更改，如果越界则报ArrayIndexOutofBounds

• 相同类型的有序集合，不允许混合类型，每个数据元素通过下标访问，下标从0开始

• 元素可以是任何数据类型，包括基本类型和引用类型

• 数组变量属于引用类型，数组也可以看成是对象，元素相当于成员变量

• 数组对象本身是在堆当中的

• 获取数组长度：arrays.length

数组的使用

For-Each 循环

总和：

  for (int i = 0; i < ints.length ; i++) {
    
    
            sum=sum+ints[i];
        }
        System.out.println(sum);

遍历：

    for (int i = 0; i < ints.length ; i++) {
    
    
        sum=sum+ints[i];
        System.out.println(sum);
    }

最大值：

for (int i = 0; i < ints.length ; i++) {
    
    
            if (ints[i]>sum){
    
    
                sum=ints[i];
            }
        }
     System.out.println(sum);
    }

多维数组

格式：int[][] arrays={ {12,12,12},{15,32,4}};

  for (int i = 0; i <arrays.length ; i++) {
    
    
            for (int j = 0; j <arrays[i].length; j++) {
    
    
                System.out.println(arrays[i][j]);
            }
        }

数组的应用

Arrays类

常用功能：

• 给数组赋值：full
• 排序：sort，升序
• 比较：equals，比较数组元素值是否相等
• 查找：binarySearch对排序好的数组进行二分查找法

打印数组元素：

int[] a={
    
    154,1,15454,3,545,6};
System.out.println(Arrays.toString(a));

升序排序：

Arrays.sort(a);
System.out.println(Arrays.toString(a));

数组填充：

Arrays.fill(a,0);
System.out.println(Arrays.toString(a));

``toString的实现：``
for (int i = 0; i <a.length ; i++) {
    
    
    if (i==0){
    
    
        System.out.print("[");
    }if (i==a.length-1){
    
    
        System.out.print(a[i]+"]");
    } else{
    
    
        System.out.print(a[i]+", ");
    }

}

稀疏数组

冒泡排序（八种排序）

1、比较数组中，两个相邻的元素，如果第一个数比第二个数大，就交换位置。

2、每次比较都会产生出一个最大，或者是最小的数字

3、以此循环比较，时间复杂度为O(n2)

public static int[] sort(int[] arrays){
    
    
        int temp=0;
        for (int i = 0; i < arrays.length-1 ; i++) {
    
    
            for (int j = 0; j < arrays.length-1-i ; j++) {
    
    
                if (arrays[j+1] < arrays[j]){
    
    
                    temp=arrays[j];
                    arrays[j]=arrays[j+1];
                    arrays[j+1]=temp;
                }
            }
        }
        return arrays;
    }

优化：[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-r9OLcR8h-1648542594652)(C:\Users\qhqz\AppData\Roaming\Typora\typora-user-images\image-20220329162820787.png)]

九、内存与初始化

• 堆：存放new的对象和数组，可以被所有的线程共享，不会被存放别的对象引用

• 栈：存放基本变量类型，会包含基本类型的具体数值；引用对象的变量，会存放这个引用在堆里面的具体地址

• 方法区：可以被所有的线程共享，包含了所有的class和static变量

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Kku8oqqD-1648542594653)(C:\Users\qhqz\AppData\Roaming\Typora\typora-user-images\image-20220328172124550.png)]

静态初始化：创建+赋值

动态初始化：创建+给予内存空间大小，且包含默认初始化

部分内容来源：B站狂神说Java、Java | 菜鸟教程