java基础

Java特性和优势

• 简单性
• 面向对象
• 可移植性
• 高性能
• 分布式
• 动态性
• 多性能
• 安全性
• 健壮性

Java的三大版本

• JavaSE：标准版（桌面应用程序、控制台开发）
• JavaME：嵌入式开发（手机）
• JavaEE：企业级开发（web端、服务器端）

JDK、JRE、JVM

安装（JDK）

JDK

1. 下载对应版本,双击安装
2. 配置环境变量
   1. JAVA_HOME
   2. CLASS_PATH
   3. path
3. 测试是否安装成功
   cmd 下执行 java-version

基础

数据类型

注：银行业务不能使用float、double表示，使用数学工具类BigDecimal类

类型转换

byte,short,char ---> int ---> long ---> float ---> double

• 强制类型转化（高 --> 低）
  • 不能对Boolean类型进行转换
  • 操作比较大的数的时候，注意溢出问题
• 自动类型转换

变量

Java是一种强类型的语言，每个变量都必须声明其类型
Java变量是程序中最基本的存储单元，包括变量名，变量类型和作用域

变量作用域

• 类变量：static修饰
• 实例变量：定义在方法外（声明可不初始化）
• 局部变量：定义在方法内（声明并初始化）

变量的命名规则

• 所有变量、方法、类型：见名知意
• 类成员变量：首字母小写和驼峰原则
• 局部变量：首字母小写和驼峰原则
• 常量：大写字母和下划线
• 类名：首字母大写和驼峰原则
• 方法名：首字母小写和驼峰原则

运算符

• 算数运算符：+、-、*、/、%、++、--
• 赋值运算符：=
• 关系运算符：>、<、>=、<=、==、!=、instanceof
• 逻辑运算符：&&、||、!
• 位运算符：&、|、^、~、>>、<<、>>>
• 条件运算符：? :
• 拓展赋值运算符：+=、-=、*=、/=

包机制

一般用公司的域名倒置作为包名

JavaDoc

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

参数

• @author 作者名
• @version 版本号
• @since 指明需要最早使用的jdk版本
• @param 参数名
• @return 返回值类型
• @throws 异常抛出情况

流程控制

用户交互Scanner

• next()

  1. 一定要读取到有效字符后才可以结束输入
  2. 对输入有效字符之前遇到的空白，next()方法会自动将其去掉
  3. 只有输入有效字符后才将其后面输入的空白作为分隔符或结束符
  4. next()不能得到带有空格的字符串

• nextLine()

  1. 以Enter为结束符也就是说nextLine()方法返回的就是输入回车之前的所有字符
  2. 可以获得空格或空白

	Scanner scanner = new Scanner(System.in);
    System.out.println("请输入多个数字");
    double str ;
    int   count = 0;
    double total = 0l;
    while(scanner.hasNextBigDecimal()){
    str = scanner.nextDouble();
    count ++;
    total+=(double)str;
    }
    System.out.println("total = "+total);
    System.out.println("count = "+count);
    System.out.println(total/count);
    scanner.close();

顺序结构

选择结构

• if单选择结构

• switch多选择结构

  • 变量类型：byte、short、int、char、jdk7之后支持String类型
  • case标签必须为字符串常量或字面量

循环结构

• while循环
• do...while循环
• for循环
• 增强for循环

break&continue

• break用于强行退出循环，不执行循环中剩余的语句
• continue用于终止某次循环，接着进行下一次的循环判定
• goto关键字

方法

方法是语句的集合，一起执行一个功能，类似于其他语言的函数

方法包含方法头和方法体

• 修饰符
• 返回值类型
• 方法名
• 参数类型
• 方法体

方法重载

• 方法名称必须相同
• 参数列表必须不同(个数不同、类型不同、参数排序顺序不同)
• 方法的返回类型可以相同也可以不同
• 仅仅返回类型不同不足以成为方法的重载

可变参数 ...

递归

递归头、递归体

数组

数组是相同类型数据的有序集合。

数组声明创建

类型[] 变量名 = 变量值 int[] a = new int[10];

数组的特点

1. 长度是确定的，数组一旦被创建，他的大小就是不可改变的
2. 其元素必须是相同类型，不允许出现混合类型
3. 数组中的元素可以是任何数据类型，包括基本类型和引用类型
4. 数组变量属引用类型，数组可以看成是对象，数组中的每个元素相当于改对象的成员变量，数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组本身是在堆中的。

数组使用

1. 普通for循环、增强for循环for-each
2. 数组作为参数
3. 数组作为返回值

多维数组

int[][] arr = new int[2][3] ; 两行三列的数组

Arrays类

冒泡

比较相邻两个数的大小，外层循环个数，内层循环比较大小

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

稀疏数组

​ 存放数组有效值的 行、列、值的一个数组

	public static void xishu(){
        System.out.println("======普通数组======");
        int[][] array = new int[6][7];
        array[0][3] = 22;
        array[0][6] = 15;
        array[1][1] = 11;
        array[1][5] = 17;
        array[2][3] = -6;
        array[3][5] = 39;
        array[4][0] = 91;
        array[5][2] = 28;
        for (int[] ints : array) {
            for (int anInt : ints)
                System.out.print(anInt+"\t");
            System.out.println();
        }
        System.out.println("======稀疏数组======");
        int sum=0; // 有效值个数
        for (int[] ints : array) {
            for (int anInt : ints) {
                if (anInt!=0)
                    sum++;
            }
        }
        System.out.println("有效值个数："+sum);
        int[][] arr = new int[sum+1][3];
        arr[0][0] = array.length; // 原始数组行
        arr[0][1] = array[0].length; //原始数组列
        arr[0][2] = sum; // 原始数组有效值个数
        int count=0;
        for (int i=0;i<array.length;i++){
            for (int j=0;j<array[i].length;j++){
                if (array[i][j]!=0){ // 存放有效值行、列、值
                    count++;
                    arr[count][0] = i;
                    arr[count][1] = j;
                    arr[count][2] = array[i][j];
                }
            }
        }
        for (int[] ints : arr) {
            for (int anInt : ints)
                System.out.print(anInt+"\t");
            System.out.println();
        }
        System.out.println("======还原数组======");
        int[][] array1 = new int[arr[0][0]][arr[0][1]];
        for (int i=1;i<arr.length;i++){
            array1[arr[i][0]][arr[i][1]] = arr[i][2]; // 原始数组有效值 所在行
        }
        for (int[] ints : array1) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
    }

面向对象OOP

本质：以类的方式组织代码，以对象的组织封装数据

• 封装（高内聚，低耦合）

  1. 提高程序的安全性，保护数据
  2. 隐藏代码的实现细节
  3. 统一接口
  4. 系统可维护性增高

• 继承（extends）

  1. 继承是类与类之间的关系
  2. Java中只有单继承没有多继承

  Object类

  super

  • super调用父类的构造方法，必须在构造方法的第一个
  • super必须只能出现在子类的方法或者构造方法中
  • super和this不能同时调用构造方法
  • this本身调用者这个对象，super父类对象的应用
  • this没有继承也可以使用，super继承才可以
  • this()本类构造，super()父类构造

  方法重写（继承）

  • 方法名、参数列表必须相同
  • 方法重写只能重写非静态的

• 多态（方法）

  • 对象能调用哪些方法，主要看对象左边的类型，和右边没有关系
  • 存在条件：继承关系，方法重写，父类引用指向子类对象

	Person a = new Student();

• 抽象类（abstract）
  • 只有方法名字没有方法体
  • 子类必须要实现抽象类的所有方法
  • 抽象类中可以写普通方法
  • 抽象方法必须写在抽象方法中
• 接口（interface）
  • 接口的本质就是锲约，接口方法默认用public abstract
  • 接口不能实例化，没有构造方法
• 内部类
  • 成员内部类
  • 静态内部类
  • 局部内部类
  • 匿名内部类

public class Outer {
    private int id = 10;
    public void out(){
        System.out.println("这是外部类");
        // 局部内部类
        class InnerP{
            public void inP(){
                System.out.println("这是局部内部类");
            }
        }
        UserSerivce userSerivce = new UserSerivce() {
            @Override
            public void hello() {
                System.out.println("Hello 匿名内部类");
            }
        };
    }
    public class Inner{
        public void in(){
            System.out.println("这是内部类");
            System.out.println("获取外部类的属性："+id);
        }
    }
}

class Test{
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.out();
        outer.new Inner().in(); //匿名内部类 不用将实例对象保存到变量中
    }
}

interface UserSerivce{
    void hello();
}

 

 

 稀疏数组的解释

public class arrayDemo05 {

 

public static void main(String[] args) {

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+"");

}

System.out.println("\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);

//创建一个稀疏数组的数组；

int[][] array2=new int [sum+1][3];

array2[0][0] = 11;

array2[0][1] = 11;

array2[0][2]=sum;

//遍历二维数组，将非0的值，存放在稀疏数组中；

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"

+ "" );

}

//还原稀疏数组

int[][] c = new int[array2[0][0]][array2[0][1]];

for(int i = 1;i<array2.length;i++) {

for(int j = 0;j<array2[i].length;j++) {

c[array2[i][0]][array2[i][1]]=array2[i][2];

}

}

System.out.println("输出还原数组");

for(int[] ints:c) {

for(int anInt:ints) {

System.out.print(anInt+"");

}

System.out.println("\t");

 

}

}

 

 

 

}

所谓稀疏数组就是用强直for循环打印一个矩阵（比如11行11列，然后取出非0的值，组成一个新的矩阵。

还原稀疏数组就是将稀疏数组的表头取出（就是原数组的行列（11-11）），然后再将稀疏数组中的第几行第几列的值还原到原数组的位置将0替换。