c 程序员java速成 java程序员自学

JAVA自学

• 软件
• Hello World

• 注释
• 关键字与标识符
• 数据类型
• 类型转换
• 变量与常量

• 变量
• 常量

• 运算符

• 算术运算符
• 关系运算符
• 逻辑运算符
• 位运算
• 三元运算符

• 包机制

• JAVA生成JAVA Doc文档

• 用cmd生成JAVA Doc文档

• 用IDEA生成JAVA Doc文档
• Scanner对象

• next方式接收
• nextLine方式接收

• 结构

• 顺序结构
• 选择结构

• if单选择结构
• if双选择结构
• if多选择结构
• 用if编写计算机程序
• 嵌套的if结构
• switch多选择结构
• 用switch语句创建个计算机

• 循环结构

• whlie循环
• do...while循环
• for循环

• 打印九九乘法表
• 输入两个数，输出最大公约数
• 增强 for循环

• break 与continue

• JAVA方法

• 方法的定义
• 方法调用
• 方法的重载
• 命令行传参
• 可变参数
• 递归

• 数组

• 数组声明创建
• 三种初始化及内存分析

• 内存分析
• 三种初始化

• 数组的四个基本特点
• 数组边界
• 数组使用

• 普通for循环
• For - Each循环 数组做方法入参 数组做返回值

• 多维数组
• Arrays类
• 冒泡排序
• 稀疏数组

• 面向对象编程

• 对象
• 构造器

• 创建对象内存分析

• 封装
• 继承

• instanceof和类型转换

• 抽象类
• 接口

• 异常

• 异常处理

软件

环境：jdk
	编译：cmd
	文本软件：Visual Studio Code
	编译软件：idea    https://www.jetbrains.com/

	java 是值传递

	java使用栈机制

Hello World

public class hello {
	public static void main(String[] args){
		System.out.println("hello world");
	}
}

用cmd编译

在文件夹里创建：“code”文件夹 修改属性为“.java”，命名为“hello”，

编译：在cmd输入javac hello.java

所属文件夹内弹出“hello.class”文件代表编译成功

输出：cmd输入java hello 及出现：文本内容“hello world”!

在E:\前面输入cmd 快速跳转使用该文件

用IDEA编译

注释

1.单行注释    
			//注释含义
2.多行注释
			/*     
			  */
3.文档注释
		   /**
		    *
		    *
		    */

关键字与标识符

关键字：是编程语言里事先定义好并赋予特殊含义的单词，也成为保留字

标识符：经常需要定义一些符号来标记一些名称，如包名、类名、方法名、参数名、变量名等，这些符号被称为标识符
	   1.所有的标识符都应该以字母（A-Z或者a-z），美元符（$）、或者下划线（_）开始
	   2.首字符之后可以是字母、美元符、下划线或者数字的任何字符组成
	   3.不能使用关键字作为变量名或者方法名
	   4.标识符是大小写敏感的

数据类型

强类型语言（java属于）

要求变量使用要严格符合规定，所有变量都必须先定义后才能使用

弱类型语言

java的数据类型分为两大类

基本类型
引用类型

基本类型

类型转换

强制类型转换：定义值前面（），（）内写强制转换的类型 （类型）变量名。（高到低 内存溢出）

自动转换：无需加（）

变量与常量

变量

变量作用域

• 类变量
• 实例变量
• 局部变量
  
  局部变量必须声明和初始值
  实例变量从属于对象

常量

运算符

算术运算符

关系运算符

逻辑运算符

位运算

简便表达

字符串连接符 +

三元运算符

包机制

JAVA生成JAVA Doc文档

用cmd生成JAVA Doc文档

通过cmd打开文件所属命令行，输入

javadoc -encoding UTF-8 -charset UTF-8 Doc.java

用IDEA生成JAVA Doc文档

接下来在底部的Locale输入框配置语言和编码集，如下图所示，语言用zh_CN 代编中文

-encoding utf-8 -charset utf-8

Scanner对象

next方式接收

nextLine方式接收

结构

顺序结构

选择结构

if单选择结构

if双选择结构

if多选择结构

用if编写计算机程序

public class 计算机demo03 {
    public static void main(String[] args) {
        String s = "7-3";
        int num1, num2, result;
        char operator;
        num1 = Integer.valueOf(s.substring(0, 1));   // int( "7" )
        operator = s.charAt(1);
        num2 = Integer.valueOf(s.substring(2, 3));
        System.out.printf("num1: %d, num2: %d, operator: %s\n", num1, num2, operator);

        if (operator == '*') {
            System.out.println(num1 * num2);
        } else if (operator == '+') {
            System.out.println(num1 + num2);

        } else if (operator == '/') {
            System.out.println(num1 / num2);

        } else if (operator == '-') {
            System.out.println(num1 - num2);
        }
    }
}

嵌套的if结构

switch多选择结构

用switch语句创建个计算机

import java.util.Scanner;

public class 计算机demo02 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入第一个数");
        int a = scanner.nextInt();
        System.out.println("请输入第二个数");
        int b = scanner.nextInt();
        System.out.println("+请输入1,-请输入2,*请输入3,/请输入4");
        int 运算符 = scanner.nextInt();

        switch (运算符) {
            case 1:
                System.out.println(a+b);
                break;
            case 2:
                System.out.println(a-b);
                break;
            case 3:
                System.out.println(a*b);
                break;
            case 4:
                System.out.println(a/b);break;

        }
    }
}

循环结构

whlie循环

do…while循环

for循环

打印九九乘法表

输入两个数，输出最大公约数

import java.util.Scanner;

//输入两个数，输出最大公约数
public class fordemo06 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int a = scanner.nextInt();
        int b = scanner.nextInt();
        int max = 0;
        for (int i = 1; i <= a; i++) {
            if (a%i==0 &&b%i==0){
                if (i > max){
                    max = i;
                }
            }
        }
        System.out.println(a+"和"+b+"最大公约数是:"+max);
    }
}

增强 for循环

break 与continue

break

continue

JAVA方法

方法的定义

方法调用

方法的重载

命令行传参

可变参数

递归

package base.method;

public class demo05 {
    public static  void  main(String[] args){
        System.out.println(f(4));
    }

 //5! 5*4*3*2*1
    public  static int f(int n){
        if (n == 1){
            return 1 ;
        }else {
            return  n*f(n-1);
        }
    }
}

PS:小计算可以用递归，大计算吃运行

数组

数组声明创建

public class arraydemo01 {
    //变量的类型     变量的名字 = 变量的值
    //数组类型
    public static void main(String[] args) {
        int[] nums;     //1.定义,声明一个数组

        nums = new int[10];//2。这里面可以存放10个int类型的数字 创建一个数组

        //3.给数组元素中赋值
        nums[0] = 1;
        nums[1] = 2;
        nums[2] = 3;
        nums[3] = 4;
        nums[4] = 5;
        nums[5] = 6;
        nums[6] = 7;
        nums[7] = 8;

        //计算所有元素的和
        int sum = 0;
        //获取数组长度： arrays.length
        for (int i = 0;i < nums.length;i++){
            sum = sum + nums[i];
        }

        System.out.println(nums[3]);
        System.out.println("总和为："+sum);
    }
}

三种初始化及内存分析

内存分析

三种初始化

public class aarraydemo02 {
    public static void main(String[] args) {
        //静态初始化：创建+赋值
    int[] a = {1,2,3,4,5,6,7};
    System.out.println(a[2]);

    //动态初始化
        int[] b = new int[10];
        b[0] = 10;
        System.out.println(b[0]);
        System.out.println(b[1]);
    }
}

数组的四个基本特点

数组边界

数组使用

普通for循环

public class arraydemo03 {
    public static void main(String[] args) {
        int[] arrays = {1,2,3,4,5};

        //打印全部的数组元素
        for (int i = 0; i < arrays.length; i++) {
            System.out.println(arrays[i]);
        }
        System.out.println("=====================");
        //计算所有元素和
        int sum =0;
        for (int i = 0; i < arrays.length; i++) {
            sum +=  arrays[i];
        }
        System.out.println("sum="+sum);
        System.out.println("=====================");
        //查找最大元素
        int max = 0;
        for (int i = 0; i < arrays.length; i++) {
            if (arrays[i]>max);
            max = arrays[i];
        }
        System.out.println("max="+max);
    }
}

For - Each循环 数组做方法入参 数组做返回值

public class arraydemo04 {
    public static void main(String[] args) {
        int[] arrays = {1,2,3,4,5};

        int[] reverse = reverse(arrays);
        printArray(reverse);
    }

    //反转数组
    public static int[] reverse(int[] arrays){
        int[] result = new int[arrays.length];

        //反转的操作
        for (int i = 0 , j=result.length-1; i < arrays.length; i++,j--) {
            result[j] = arrays[i];
        }

        return result;
    }

    //打印数组元素
    public static void printArray(int[] arrays) {
        for (int i = 0; i < arrays.length; i++) {
            System.out.println(arrays[i]+"");
        }
    }
}

多维数组

Arrays类

package base.array;

import java.lang.reflect.Array;
import java.util.Arrays;

public class arraydemo06 {
    public static void main(String[] args) {

        int[] a = {1,2,555,22,35,15534,21};

        System.out.println(a);//[I@776ec8df

        //打印数组元素Arrays.toString（a）
       System.out.println(Arrays.toString(a));
        printArray(a);  //方法调用
        Arrays.sort(a);//数组进行排序：升序
        System.out.println(Arrays.toString(a));
    }

    public static void printArray(int[] a) {
        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]+",");
            }

        }

    }
}

冒泡排序

package base.array;

import java.util.Arrays;

public class demo07 {
    public static void main(String[] args) {
        int[] a = {1,2,46,556,13,54,11,956};

        int[] liuliu = liuliu(a);//调用完我们自己写的排序方法以后，返回一个排序后的数组

        System.out.println(Arrays.toString(liuliu));

    }
    //冒泡排序
    //1.比较数组中，两个相邻的元素，如果第一个数比第二个数大，我们就交换他们的位置
    //2.每一次比较，都会产生出一个最大，或者最小的数字；
    //3.下一轮则可以少一次排序！
    //4.依次循环，直到结束！
    public static int[] liuliu(int[] array) {
        //临时变量
        int tep = 0;

        //外层循环，判断我们这个要走多少次；
        for (int i = 0; i < array.length - 1; i++) {
            //内层循环，比价判断两个数，如果第一个数，比第二个数大，则交换位置

            for (int j = 0; j < array.length-1-i; j++) {
                if (array[j+1]<array[j]){   // < 是从小到大，>是从大到小
                tep = array[j];
                array[j]=array[j+1];
                array[j+1] = tep;
                }
            }
            
        }
        return  array;
    }
}

稀疏数组

package base.array;

public class arraydemo08 {
    public static void main(String[] args) {
        //1.创建一个二维数组11*11   0：没有棋子    1，黑子    2，白子
        int [][] array1 = new int[11][11];
        array1[1][2] = 1;
        array1[2][3] = 2;
        //输出原始数组
        System.out.println("输出原始的数组");

        for (int[] ints : array1){
            for (int anInt :ints){
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }

        //转换为稀疏数组
        int sum = 0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (array1[i][j] != 0){
                     sum ++;
                }
            }

        }
        System.out.println("有效值的个数："+sum);

        //2,创建一个稀疏数组的数组
        int[][] array2 = new int[sum+1][3];

        array2[0][0] = 11;
        array2[0][1] = 11;
        array2[0][2] = sum;

        //遍历二维数组，将非零的值，存放稀疏数组中
        int count = 0;
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1[i].length; j++) {
                if (array1[i][j] != 0){
                    count++;
                    array2[count][0] = i;
                    array2[count][1] = j;
                    array2[count][2] = array1[i][j];
                }
            }
        }
        //输出稀疏数组
        System.out.println("稀疏数组");

        for (int i = 0; i < array2.length; i++) {
            System.out.println(array2[i][0]+"\t"
            +array2[i][1]+"\t"
            +array2[i][2]+"\t");

        }

        System.out.println("还原");
        //1.读取稀疏数组
        int[][] array3 = new int[array2[0][0]][array2[0][1]];

        //2.给其中的元素还原他的值
        for (int i = 1; i < array2.length; i++) {
            array3[array2[i][0]][array2[i][1]] = array2[i][2];
        }
        //3.打印
        System.out.println("输出原始的数组");

        for (int[] ints : array3){
            for (int anInt :ints){89                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
    }
}

面向对象编程

对象

构造器

构造器：

1.和类名相同

2.没有返回值

作用：

1.new本质调用构造方法

2.初始化对象的值

注意点：

1.定义有参构造之后，如果想使用无参构造，显示的定义一个无参的构造

方法一：

方法二：

创建对象内存分析

封装

继承

• 私有的东西无法被继承
• 子类继承了父类，就有父类所有的方法
• 在java中，所有的类，都被默认直接或者简介继承object
• 隐藏代码：调用了父类的无参构造
• 调用父类的构造器，必须要在子类构造器，必须要在子类构造器的第一行

object类

super类

重写

非静态才是重写！

多态

instanceof和类型转换

instanceof

instanceof是Java的一个保留关键字，左边是对象，右边是类，返回类型是Boolean(false;true)类型。它的具体作用是测试左边的对象是否是右边类或者该类的子类创建的实例对象，是，则返回true，否则返回false。

类型转换

抽象类

接口

异常

异常处理