本文主要是介绍Java基础，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

Java基础

标识符

注释

/*
	单行注释 ：//
	多行注释 ：/* */
/*  文档注释 ：/**
			  *
			  *
			  */
			
	

标识符注意点

• 所有的标识符都以字母(A-Z , a-z)，美元符($)，下划线（_）开始
• 首字符之后可以是字母，美元符，下划线，或者数字的任意字符组合
• 不能使用关键字作为变量名或者方法名
• 标识符对大小写敏感
• 可以使用中文命名，但是一般不建议这样去做

数据类型

强类型语言

• 变量使用要严格符合规定，所有变量要先定义后使用

Java的数据类型分为两大类

基本数据类型(Primitive Type)

• 数值类型

  • 整数类型

    • byte 1字节 ：-127—127
    • short 2字节 ：-2^16—216-1
    • int 4字节 : -2^32—232-1
    • long 8字节 : -2^64—264-1

  • 浮点类型

    • float 4字节
    • double 8字节
• boolean : 只有true与false

引用数据类型(Reference Type)

• 类
  • String 字符串
• 接口
• 数组

数据类型拓展

public class Practice {
    public static void main(String[] args) {
        int i = 10;
        int i2 = 010;	//八进制0
        int i3 = 0x10;  //十六进制0x

        System.out.println(i);
        System.out.println(i2);
        System.out.println(i3);
        System.out.println("======================");

        //浮点数拓展
        //BigDecimal 数学工具类

        //float
        //double
        float f = 0.1f; //0.1
        double d = 1.0/10; //0.1
        System.out.println(f==d); //print false

        float d1 = 2323156156654654646f;
        float d2 = d1+1;
        System.out.println(d1==d2); //print true

        //字符拓展
        System.out.println("=====================");
        char c1 = 'a';
        char c2 = '中';
        System.out.println(c1);
        System.out.println((int)c1);
        System.out.println(c2);
        System.out.println((int)c2);
        //编码 Unicode 0 - 65536
        
        //转义字符
        // \t \n \\ \" \' \? \0 ...
        System.out.println("Hello\nWord");
    }
}

类型转换

• Java是强类型语言，所以要进行有些运算时，需要进行类型转换

  低	········································-> 高
  byte，short,char-> int -> long -> float -> double
  

• 运算中,不同类型的数据先转换为同一类型然后再进行计算

  • 强制类型转换 （高 到 低）
  • 自动类型转换 （低 到 高）

注意点

1. 不能对布尔值进行类型转换

2. 不能把对象类型转换为不相干的类型

3. 再把高容量转换到低容量的时候，强制转换

4. 转换时可能存在内存溢出问题，或者精度问题

   ---

public class Practice_2 {
    public static void main(String[] args) {
        int i = 128;
        //强制转换
        byte b = (byte)i;   //内存溢出
        System.out.println(i);
        System.out.println(b);
        // 精度损失
        System.out.println("====================");
        System.out.println((int)23.7);  //23
        System.out.println((int)-45.89f);   //-45
        //char - int
        System.out.println("====================");
        char c = 'a';
        int d = c+1;    //自动转换
        System.out.println(d);  //put 98
        System.out.println((char)d);    //put b
        //注意溢出
        //操作比较大的数时，要注意溢出问题
        //JDK7新特性，数字之间可以用下划线分割
        int money = 10_0000_0000;
        int years = 20;
        int  total_1 = money*years;   //-1474836480,溢出 ！
        long total_2 = money*years;     //money*years   为int类型，转换前以经溢出
        long total_3 = money*(long)years;     //正常输出

        System.out.println(total_1);
        System.out.println(total_2);
        System.out.println(total_3);
    }
}

变量

变量：可以修改的值（c语言 可修改的左值）
Java是一种强类型语言，每个变量都必须声明其类型
变量要素包括：变量名，变量类型，作用域

• 注意事项
  • 每个变量都有类型，基本类型或者引用类型
  • 变量名必须是合法的标识符
  • 一条完整的语句声明变量以分号结束

变量作用域

• 类变量：类变量也声明在类中，方法体之外，但必须声明为 static 类型
• 实列变量：成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问
• 局部变量：在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。

常量

初始化后不可以改变的值

• 注意事项
  • 被设定后不可改变
  • 常量名一般采用大写字母

命名规范

• 所有变量，方法，类名：见章知意
• 类成员变量，局部变量，首字母小写和驼峰原则：如 lastName , monthSalary
• 常量：大写字母和下划线：如 MAX_VALUE
• 类名：首字母大写和下划线
• 方法名：首字母小写和驼峰原则

public class Practice_3 {
    //属性：变量

    //类变量 static
    static double salary = 2500;
    //实例变量: 从属于对象: 如果不自行初始化，这个类型默认值 0 0.0
    //布尔值：默认是false
    //除了基本类型，其余都是null
    String name;
    int age;

    //常量 final
    static final double PI = 3.1415;

    //main方法
    public static void main(String[] args) {

        //局部变量：必须声明和初始化值
        int i = 10;

        System.out.println(i);
        //变量类型 变量名字 = new Practice_3();
        Practice_3 practice_3 = new Practice_3();
        System.out.println(practice_3.age);
        System.out.println(practice_3.name);

        //类变量 static
        System.out.println(salary);

        //常量 final
        System.out.println(PI);
    }

    //其它方法
    public void add(){
    }
}

Java运算符

• 算数运算符：+ ，-，*，/，++，–
• 赋值运算符：= ，+= ，-= ，*= ，/=
• 关系运算符：< , > , >= , <= , == , !=
• 逻辑运算符：&& , || , !
• 位运算符：& , | , ^ , ~ , >> , << ,>>>
• 条件运算符： ？ ：

包机制

Java 包(package)

为了更好地组织类，Java 提供了包机制，用于区别类名的命名空间

• 包的作用

  • 把功能相似或相关的类或接口组织在同一个包中，方便类的查找和使用
  • 如同文件夹一样，包也采用了树形目录的存储方式。同一个包中的类名字是不同的，不同的包中的类的名字是可以相同的，***当同时调用两个不同包中相同类名的类时，应该加上包名加以区别。***因此，包可以避免名字冲突
  • 包也限定了访问权限，拥有包访问权限的类才能访问某个包中的类

• 包的语法格式

  package pkg1[．pkg2[．pkg3…]];
  

import 关键字

为了能够使用某一个包的成员，我们需要在 Java 程序中明确导入该包。使用 “import” 语句可完成此功能。

• 在 java 源文件中 import 语句应位于 package 语句之后，所有类的定义之前，可以没有，也可以有多条，其语法格式为：

  import package1[.package2…].(classname|*);
  

• 如果在一个包中，一个类想要使用本包中的另一个类，那么该包名可以省略

JavaDoc

• javadoc命令是用来生成自己API文档的

  避免乱码 -encoding UTF-8 -charset UTF-8

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

Scanner

• Java.util.Scanner是Java5的新特性，通过Scanner类来获取用户的输入
• 基本语法：Scanner s = new Scanner(Syatem.in);
• next() 和 nextLine() 方法获取输入字符串，使用```hasNext() 和 hasNextLine() 判断是否还有输入的数据

/*	next();
	1.读取到有效字符后才可以结束
	2.有效字符之前遇到空白，next()方法会自动将其去掉
	3.只有输入有效字符之后才将其后面的空白作为分隔符或者结束符
	4.next()不能的都带有空格的字符
*/
package com.baidu.www.scanner;

import java.util.Scanner;

public class Demo01 {
    public static void main(String[] args) {
        //创建一个扫描器对象，用于接受键盘数据
        Scanner scanner = new Scanner(System.in);

        System.out.println("使用next方式接受: ");

        //判断用户有没有输入字符串
        if (scanner.hasNext()){
            String str = scanner.next();
            System.out.println("输出的: "+str);
        }
        //凡是属于IO流的类如果不关闭就会一直占用资源
        scanner.close();
    }
}

/*	nextLine();
	1.以Enter为结束符
	2.可以获得空白
*/
package com.baidu.www.scanner;

import java.util.Scanner;

public class Demo02 {
    public static void main(String[] args) {
        //创建一个扫描器对象，用于接受键盘数据
        Scanner scanner = new Scanner(System.in);

        System.out.println("使用nextLine方式接受: ");

        //判断用户有没有输入字符串
        if (scanner.hasNextLine()) {
            String str = scanner.nextLine();
            System.out.println("输出的: " + str);
        }
        //凡是属于IO流的类如果不关闭就会一直占用资源
        scanner.close();
    }
}

结构

顺序结构

选择结构

• if else 结构

• switch 结构

• goto 结构

循环结构

• While循环
• Do While循环
• For 循环
• 增强for循环

continue，break

package com.baidu.www.scanner;

public class Demo03 {
    public static void main(String[] args) {
        int[] number = {10,20,30,40,50};

        for (int i = 0; i < 5; i++) {
            System.out.println(number[i]);
        }
        System.out.println("==============");
        //For 增强
        for (int x:number){
            System.out.println(x);
        }
    }
}

方法

• 如：System.out.println();
  

• Java是一系列语句的集合，它们在一起执行一个功能

  • 方法是解决一类问题的步骤的有序组合
  • 方法包含类和对象中
  • 方法在程序中被创建，在其他地方被引用

• 设计方法原则：方法的本意是功能块，就是实现某个语句块的集合。我们设计方法的时候，最好保持方法的原子性，就是一个方法只完成一个功能

• 方法命名规则：首字母小写和驼峰原则

方法的定义

• 修饰符 ：可选，告诉编译器如何调用该方法。定义了该方法的访问类型
• 返回值类型 ：returnValueType ，没有返回值void
• 方法名 ：是方法的实际名。方法名和参数表共同构成方法签名
• 参数类型 ：
  • 形式参数 ：被调函数中使用的在函数头中声明的参数
  • 实际参数 ：调用函数时传递给函数时的实际值
  • Java方法传递参数均为值传递
• 方法体 ：方法体包含具体的语句，定义方法的功能
• 异常抛出

方法重载

• 重载就是在一个类中，有相同的函数名称，但形式参数不同
• 方法重载的规则
  • 方法名称必须相同
  • 参数列表必须不同（个数，类型，参数排列顺序不同等）
  • 方法的返回值类型可以相同也可以不同
  • 仅仅返回类型不同不足以成为方法的重载
• 实现理论：
  • 方法名称相同时，编译器会根据调用方法的参数个数，类型，顺序等逐个去匹配方法，如果失败会报错

package com.baidu.www.method;

public class Demo02 {
    public static void main(String[] args) {
        double max_1;
        int max_2;
        max_1 = max(20.0,10.0);
        max_2 = max(20,10);

        if (max_1 == -1)
            System.out.println("equal");
        else
            System.out.println(max_1);

        System.out.println((max_2==0 ? "equal" : max_2));
    }

    public static int max(int x1,int x2){
        if(x1 == x2)
            return 0;
        else
            return (x1 > x2) ? x1 : x2;
    }

    public  static double max(double x1,double x2){
        if(x1 == x2)
            return -1.0;
        else
            return (x1 > x2) ? x1 : x2;
    }
}

方法的递归

• 递归就是A方法自己调用自己
• 递归包括两个部分：
  • 递归头：什么时候不调用自己，如果没有头，将陷入死循环
  • 递归体：什么时候需要调用自身方法

package com.baidu.www.method;

public class Demo04 {
    public static void main(String[] args) {
        System.out.println(test(10));
    }

    public static int test(int n){
        if (n==1)
            return 1;
        else
            return n*test(n-1);
    }
}

方法的调用

• 静态方法

• 非静态方法

• 形参和实参

• 值的传递和引用传递

• this关键字

数组

数组的定义

• 数组是相同类型的数据的有效集合
• 数组描述的是相同类型的若干数据，按照一定的先后次序排列组合而成
• 其中，每一个数据称为一个数据元素，每一个数组元素可以通过一个下标来访问它们

数组的声明创建

• 首先需要声明数组：

  dataType[] arrayRefVar;	//首选方法
  
  dateType arrayRefVar[];	//向c兼容
  

• Java语言使用new操作符来创建数组，语法如下：

  arrayRefVar = new dateType[arraySize];
  

• 数组元素是通过索引访问的，数组索引从开始

• 获取数组长度：arrays.length

数组的使用

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

package com.baidu.www.array;

public class ArrayDemo01 {
    public static void main(String[] args) {
        int[] arrays = {1,2,3,4,5,6,7,8,9};

        view(arrays);
        System.out.println("\n");
        view(revert(arrays));
    }
    //打印数组
    public static void view(int[] arrays){
        for (int array : arrays) {
            System.out.print(array + " ");
        }
    }
    public static int[] revert(int[] arrays){
        int[] arrayRevert = new int[arrays.length];
        for (int i=0,j=arrays.length-1;i <arrays.length;i++,j--){
            arrayRevert[j] = arrays[i];
        }
        return  arrayRevert;
    }
}

二维数组

public class ArrayDemo02 {
    public static void main(String[] args) {
        int[][] arrays = {
                {1,2,3,5,6,6},
                {2,5,6,68,5},
                {2,3,5,6,8,9,8},
                {2,3,5,8,9,10}};
        for (int i = 0; i < arrays.length; i++) {
            for (int j = 0; j < arrays[i].length; j++) {
                System.out.print(arrays[i][j]+" ");
            }
            System.out.println();
        }
    }
}

冒泡排序

package com.baidu.www.array;

import java.util.Arrays;

public class ArraysDemo03 {
    public static void main(String[] args) {
        int[] array = {1,2,3,2,5,7,8,9};

        System.out.println(Arrays.toString(sort(array)));
    }
    public static int[] sort(int[] array){
        //int middle;
        for (int i = 0; i < array.length-1; i++) {
            boolean flag = false;   //记号
            for (int j = array.length-1; j > i; j--) {
                if(array[j] < array[j-1]) {
                    /*
                    middle = array[j];
                    array[j] = array[j-1];
                    array[j-1] = middle;
                    */
                    array[j] = array[j]^array[j-1];
                    array[j-1] = array[j-1]^array[j];
                    array[j] = array[j-1]^array[j];     //交换数值
                    flag = true;                        //标志排序
                }
            }
            if(!flag)
                break;
        }
        return array;
    }
}

稀疏数组

import java.util.Arrays;

public class ArrayDemo04 {
    public static void main(String[] args) {
        //创建一个11*11的数组
        //(1,2) = 2 , (4,5) = 1
        int[][] arrays1 = new int[11][11];
        arrays1[1][2] = 2;
        arrays1[4][5] = 1;

        //输出原始数组
        for (int[] ints : arrays1) {
            for (int anInt : ints) {
                System.out.print(anInt + "\t");
            }
            System.out.println();
        }
        System.out.println();

        //获取已初始个数
        int num = 0;
        for (int[] ints : arrays1) {
            for (int anInt : ints) {
                if (anInt != 0)
                    num++;
            }
        }

        //创建稀疏数组 num+1;
        int[][] arrays2 = new int[num+1][3];
        arrays2[0][0] = 11;     //11 行
        arrays2[0][1] = 11;     //11 列
        arrays2[0][2] = num;    //有效值个数

        //将有效数值赋值给稀疏数组
        int order = 0;
        for (int i = 0; i < arrays1.length; i++) {
            for (int j = 0; j < arrays1[i].length; j++) {
                if(arrays1[i][j] != 0){
                    order++;
                    arrays2[order][0] = i;
                    arrays2[order][1] = j;
                    arrays2[order][2] = arrays1[i][j];
                }
            }
        }

        //打印稀疏数组
        for (int[] ints : arrays2) {
            System.out.println(Arrays.toString(ints));
        }
        System.out.println();

        //还原数组
        int[][] arrays3 = new int[11][11];
        for (int i = 0; i < arrays2[0][2]; i++) {
            arrays3[ arrays2[i+1][0] ][ arrays2[i+1][1] ] = arrays2[i+1][2];
        }

        //打印已还原数组
        for (int[] ints : arrays3) {
            for (int anInt : ints) {
                System.out.print(anInt + "\t");
            }
            System.out.println();
        }
    }
}

Java内存

• 堆

  存放new的对象和数组

  可以被所有线程共享，不会存放别的对像引用

• 栈

  存放基本变量类型（会包含这个基本类型的具体数值）

  引用对象的变量（会存放这个引用在堆里面的具体地址）

• 方法区

  可以被所有线程共享

  包含了所有class和static变量

面向对象

​ 对于描述复杂的事物，为了从宏观上把握，从整体上分析，我们需要使用面对对象的思路来分析整个系统。但是具体到微观操作，任然需要面对过程的思路去处理

面向对象编程（Object-Oriented Programming，OOP）

以类方式组织代码，以对象组织（封装）数据

三大特性：封装，继承，多态

对象和类

• 对象：对象是类的一个实例（对象不是找个女朋友），有状态和行为。例如，一条狗是一个对象，它的状态有：颜色、名字、品种；行为有：摇尾巴、叫、吃等
• 类：类是一个模板，它描述一类对象的行为和状态

/* 实例化对象 */
Object referenceVariable = new Constructor();
/* 访问类中的变量 */
referenceVariable.variableName;
/* 访问类中的方法 */
referenceVariable.methodName();

这篇关于Java基础的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！