学习Java之路---Java基础（知识补充版）

1.java基础

1.1 注释

• //单行注释

• /* 多行注释*/

• /**

  *文档注释

  *文档注释

  */

1.2 标识符

• 所有的标识符都是以字符、$、下划线开头；

• 标识符是大小写敏感的。

1.3数据类型

基本类型

Byte char short int long(3L) float(5.1F) double boolean

1 2 2 4 8 4 8

（强制类型转换时，不能对boolean转换且只能由低到高）

---

引用类型

String，接口，数组；

---

• 二进制0b，八进制0，十六进制0x；

• 数字之间可以用下划线分割 10_0000_000

---

面试拓展： 1.因为float类型的数由舍入误差，所以尽量少用float 类型做比较；

2.new两个相同String，比较时返回false；直接给String赋值，比较时返回true。

1.4变量与常量

变量

• 局部变量：存在与函数方法体中，定义时需要初始化；

• 实例变量：存在与类中且函数方法体外，函数方法体内使用时需要先创建一个实例对象；

• 类变量：与实例对象位置相同，定义时需要加static且需要初始化（随类创建时产生）。

---

常量

定义时需要加final，且习惯使用大写字母定义；

---

1.5运算符

• ++：a++先赋值后加加；

• -- ：--a先减减后赋值；

• A&B:同0为0，同1为1，异为0

• A|B:同0为0，同1为1，异为1

• A^B：同为0，异为1

• ~B：取反

• 》》：右移/2

• 《《：左移*2

• 推荐使用（）提升运算符

---

面试拓展：

1.6包机制

一般利用公司域名倒置命名包 www.baidu.com >> com.baidu.www

---

1.7JavaDoc

1.为类或类变量加文件注释；

2.在【cmd】中输入：javadoc -encoding UTF-8 -charset UTF-8 java文件名 即可生成帮助文档。

---

【java帮助文档】 Java Platform SE 8

---

2.java流程控制

2.1用户交互Scanner

详细语法

Scanner s=new Scanner(System.in);
System.out.println("请输入字符：");
//next()不能得到有空格的字符串
//nextLine()可以获得空白
if(s.hasNext())
{
    String str=s.next();
    //如果输入整数时，可更改为nextInt()
    System.out.println("输入next字符为："+str);
}
    String str2=s.nextLine();
    System.out.println("输入nextLine字符为："+str2);
​
s.close();

2.2选择结构

switch选择结构

switch(属性名){
    case 条件1：执行语句；break;
    case 条件2：执行语句：break;
      ·
      ·
   default:执行语句；
}

2.3循环结构

while循环

判断条件为true则执行；

do while循环

至少执行一次；

for循环

【快捷键】100.for

增强for循环(适用于数组)

【语法格式】for(int x:数组名){}

【终止循环】break 跳出循环； continue 跳过某次循环；

---

常见转义字符

\t 空格 \n 换行

---

3.java方法

面试拓展：【值传递和引用传递】

1.值传递是指：仅将实参的值传给形参，在函数中改变形参的值，不影响实参。实参和形参在内存中的位置不同；

2.引用传递是指：实参传递给参数的地址，在函数中改变形参的值，将同时改变实参。实参和形参指向内存中同一位置；

3.java中通常使用值传递。

可变参数 （int... numbers）

一个函数中只能指定一个可变参数，且必须是最后一个参数。

递归

• 递归头：什么时候不调用自身方法（边界条件）；

• 递归体：什么时候需要调用自身方法；

4.数组

4.1数组的声明和创建

int[] nums=new int[10];   //创建10个数组空间

静态初始化

int[] nums={1,2,3,4,5};

动态初始化

int[] nums=new [10]; nums[0]=1 ......;

4.2多维数组

int[][] nums1=new int[2][3];  //定义了2行3列的二维数组
int[][] numus2={{1,2},{1,2},{1,2}}    //初始化

4.3Arrays类

java中利用Arrays类提供了对数组的输出，排序等基础方法；

4.4冒泡排序

//每次循环将最值放置在尾部
int[] nums={2,5,7,3,4,1,8};
//外层控制循环次数   N-1次；
for(int i=0;i<nums.length-1;i++)
{
    //内层实现数值交换；
    for(int j=0;j<nums.length-i-1;j++){
        if(nums[j]<nums[j+1]){
            int temp=nums[j];
            nums[j]=nums[j+1];
            nums[j+1]=temp;
        }
    }
}
System.out.println(Arrays.toString(nums));

4.5稀疏数组

int[][] array=new int[11][11];
        array[1][2]=1;
        array[2][3]=2;
        //记录有效数字的个数
        int sum=0;
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                if(array[i][j]!=0)
                {
                    sum++;
                }
            }
        }
        System.out.println("有效数字的个数为："+sum);
        //创建稀疏数组（sum+1行3列的数组)
        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 < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                if(array[i][j]!=0)
                {
                    count++;
                    //记录有效数字的行号、列号和值
                    array2[count][0]=i;
                    array2[count][1]=j;
                    array2[count][2]=array[i][j];
                }
            }
        }
        //输出稀疏数组
        for (int i = 0; i < array2.length; i++) {
            for (int j = 0; j < array2[i].length; j++) {
                System.out.print(array2[i][j]+" ");
            }
            System.out.println();
        }
        System.out.println("========================");
        //由稀疏数组转变为普通数组
        int[][] array3=new int[array2[0][0]][array2[0][1]];
        for (int i = 1; i < array2.length; i++) {
                //根据稀疏数组记录的行列号直接赋值
                array3[array2[i][0]][array2[i][1]]=array2[i][2];
​
        }
        //输出普通数组
        for (int i = 0; i < array3.length; i++) {
            for(int j=0;j<array3[i].length;j++){
                System.out.print(array3[i][j]+" ");
            }
            System.out.println();
        }

5面向对象编程

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

5.1类的调用

• 静态方法调用（定义方法时加static） 》》》 类名.方法名（）；

• 非静态方法调用 先创建对象，然后对象名.方法（）；

5.2构造器

构造器用来实例化初始值

• 定义有参构造器时，必须显式无参构造器；

• 【快捷键】alt+insert 自动生成构造器；

5.3三大特性

封装

封装数据，实现高内聚低耦合；

---

继承 extends

• java中只能有单继承（一个子类只能有一个父类）；

• Object类为所有类的父类；

• 【快捷键】ctrl+H 打开继承树；

• 子类方法中调用父类的属性或方法，可使用Super；

• 子类构造器调用父类无参构造器时，super()须在首行；

• super和this不能同时调用构造器。

• 只能重写非静态方法；

---

多态

//多态只有方法的多态
//父类的引用指向子类，此时对象f只能调用父类中存在的方法
Father  f=new Son();  
Son   s=new Son();
f.run();
s.run();
//实现了run方法的重写，此时两个都执行子类重写后的方法

5.4static关键字详解

用static修饰属性或方法时，属性和方法在类创建时产生

• 可直接用类名.属性，调用类变量；

• 静态方法中不能调用非静态方法；

• static{
      //静态代码块：首先执行，且只执行一次
      //可用于赋值初始值
  }

5.5抽象类 abstract

抽象方法必须在抽象类中，但抽象类中可以有普通方法；

---

5.6接口 interface

• 接口可以多继承；

• 接口中定义的属性，默认为常量 public static final；

• 接口中的方法，默认为public static;

• 设置实现类的关键字：implements；

5.7内部类

成员内部类

//在类中创建public类，则为内部类
//内部类可以访问所属外部类的私有方法和私有属性
//内部类的创建需要依靠外部类对象
Outer o=new Outer();
o.Inner in=o.new Inner();

静态内部类

定义staitc修饰的内部类；

局部内部类

在方法中定义内部类；

匿名内部类

没有名字初始化类；

6异常机制

6.1异常处理机制

try{
    //捕获异常
}catch(Exception e){
    //Throwable>Error=Exception  异常的类型
}finally{
    //无论是否异常，都会执行
    //添加finally语句可以释放占用的资源
}

【快捷键】ctrl+alt+T 自动包裹代码

6.2自定义异常

1.自定义异常类，继承Exception类；

2.在可能出现异常的方法中throws异常；

3.在mian方法中捕获异常（try-catch）；