java基础梳理

环境变量path和classpath的作用是什么？

path变量是Windows程序文件的目录，作用是指定DOS命令行下命令的路径

classpath变量值是java类文件的目录，作用是指定类搜索路径。JVM就是通过classoath来寻找该类的字节码文件的。

八进制和十六进制与十进制的转换

基本数据类型

1字节的：byte boolean

2字节的：short char

4字节的：int float

8字节的：double long

注意：整型默认是int，浮点型默认是double

数据类型的转换

• 参与运算的数据类型要一致
• 容量小的类型默认转换为容量大的类型
• byte,short,char---int ---long ---float---double
• 注意：byte，short，char之间不会互相转换，他们三者在计算时会首先转换为int类型

&&（短路与）和&（与）的区别？

• &&左边false了，右边就不操作了
• &左边false了，右边还得继续操作

||和|的区别？

• ||左边true了，右边就不操作了
• |左边true了，右边还的继续操作

位运算符

switch 用于定义选择结构范围：

• 被选择的结果，该表达式只能有4种类型：byte，short，int，char，enum（jdk5后）,String (JDK7后)
• default：当所有的case都不匹配时执行default里面的内容

如何自定义函数？

• 明确函数的返回值类型
• 明确参数列表（形参的类型及个数）

函数的重载？

• 在同一个类中，允许存在一个以上的同名函数，只要他们的参数个数或者参数类型不同即可
• 函数的功能一样，仅仅是参与运算的未知内容不同时，可以定义对个函数，却是用统一函数名称
• 与返回值无关
• 判断是否重载：函数名相同，参数列表不同（个数和类型）

堆内存中的数据怎么样判断他是否不被使用？

选择排序：

原理：先从弄0角标位置元素与其他位置元素（自己除外）进行一次比较，每次比较完后，最小值出现在最 左边，并将起始位置后移一个角标，直至次尾角标位。

package com.xteslife.exel;

/**
 * @author 小涛
 * @create 2019-05-26  17:53
 */
public class ArrayListTest {
    public static void main(String[] args) {
       int[] array= new int[]{2, 1, 43, 23, 18};
        selectSort(array);
        for (int x:array)
            System.out.println(x);
    }
    public static void selectSort(int[] arr){
        for(int i=0;i<arr.length-1;i++){
            for (int y=i+1;y<arr.length;y++){
                if(arr[i]>arr[y]){
                    /*arr[i]=arr[i]+arr[y];
                    arr[y]=arr[i]-arr[y];
                    arr[i]=arr[i]-arr[y];*/
                    arr[i]=arr[i]^arr[y];
                    arr[y]=arr[i]^arr[y];
                    arr[i]=arr[i]^arr[y];
                }
            }
        }
    }
}

冒泡排序

原理：相邻的元素，两两相比，大的后移。每次比较玩，最大值出现在右边。

N个数字要排序完成，总共进行N-1趟排序，每第i趟的排序次数为（N-1）次，所以可以用双循环语句，外层控制循环多少趟，内层控制每一次的循环次数

冒泡排序法口诀

外层循环 0到n-1 //控制比较轮数 N表示元素的个数

内层循环 0到n-i-1 //控制每一轮比较次数

两两比较做交换

  public static void bubbleSort(int[] arr){
        for (int i=0;i<arr.length-1;i++){
            for(int y=0;y<arr.length-i-1;y++){
                if (arr[y]>arr[y+1]){
                    arr[y]=arr[y]^arr[y+1];
                    arr[y+1]=arr[y]^arr[y+1];
                    arr[y]=arr[y]^arr[y+1];
                }
            }
        }
    }

成员变量和局部变量的区别

• 作用范围
  • 成员变量作用于整个类
  • 局部变量只作用于它所属的范围
• 生命周期和位置
  • 成员变量存储在堆内存中，是属于对象的，随着对象的存在而存在，随着对象的消失而消失
  • 局部变量存储在栈内存中，是属于它所属的范围，使用完立即被释放
• 初始值
  • 成员变量都有默认初始值
  • 局部变量没有默认值，要想使用必须遵循
    • 先定义（声明）再赋值，最后使用

构造方法

• 自定义类中如果没有构造方法，系统会默认给出一个午餐构造方法
• 如果你给定了构造方法，系统将不再提供无参构造方法了
• 建议：每次我们都手动给出无参构造方法

this的三种使用场景

• 局部变量隐藏成员变量
• 构造方法中使用this
• 比较年龄

内存图

代码块

定义

他是由一对{}括起来的代码

分类：

• 局部代码块：用在局部可以及时释放内存，提高效率
• 构造代码块：每个构造方法运行时都会自动调用构造代码块，可以对所有对象初始化
• 静态代码块：随着类的加载而执行，而且只执行一次，优先于主方法

假如我们有一个Persion对象，请问Persion p = new Persion(); 在内存中到底做了什么？

步骤：

• 把Persion.class问价加载近内存
• 在栈内存空间开批一个小空间，存储P变量
• 在堆内存中开辟空间。创建对象
• 对对象中的成员变量进行默认初始化
• 执行构造代码块，如果没有构造代码块，就不执行
• 对对象中的成员变量进行赋值
• 把对象构造初始化完毕
• 将对象在堆内存的首地址赋给栈内存变量P

static

特点：

• 随着类的加载而加载
• 优先于对象存在
• 被所有对象共享
• 可以直接被类名调用

注意事项：

1. 静态成员只能访问静态成员
2. 静态方法中不能有this和super关键字
3. 主函数是静态的

静态变量和非静态变量的区别

A：静态变量随着类的加载而加载，随着类的消失而消失。生命周期最长。

​ 非静态变量随着对象的创建而存在，随着对象的消失而消失。

B：静态变量和类相关，是所属于类的，可以直接被类名调用，也可以被对象名调用。

也称为类变量。

​ 非静态变量和对象相关，是所属于对象的，只能被对象名调用。称为实例(对象)变

量。

C：静态变量存储于方法区中的静态区。

​ 非静态变量存储于对象的区域，在堆内存中。

D：静态变量的数据被所有的对象共享。

​ 非静态变量是每个对象特有的数据。

某个成员方法访问了静态成员，那么该方法就必须定义为static修饰的。

在IDEA中怎么制作帮助文档

单例设计模式

• 保证对象在内存中只有一个

• 如何保证？

  • 不能让其他类来创建对象
  • 本类中要创建一一个本类的对象
  • 对外提供公共的方法

• 什么时候是用呢？

  • 配置文件

• 单列的两种模式

  • 第一种:饿汉模式

    class Teacher{
        //创建一个本类对象
        private static Teacher t = new Teacher();
        //为了保证其他类不能够创建对象（将构造方法私有化）
        private Teacher(){}
        //为了让外界能够通过类名直接调用
        public static Teacher getInstance(){
            return t;
        }
        Teacher t1 = Teacher.getInstance();
        Teacher t2 = Teacher.getIndtance();
    }

  • 第二种方式：懒汉式

    class Teacher{
        //创建一个本类对象
        private static Teacher t = null;
        //为了保证其他类不能够创建对象
        private Teacher(){}
        //为了外界能够通过类名直接调用
        public static Teacher getInstance(){
            if(t==null){
                Synchronized(Teacher.class){
                    if(t==null){
                        t = new Teacher();
                    }
                }
            }
            return t;
        }
        Teacher t1 = Teacher.getInstance();
        Teacher t2 = Teacher.getInstance();
    }

• 注意：开发一般使用饿汉式，第二种在多线程的时候会有安全隐患

• 面试一般考懒汉式（延迟加载）

继承

特点：

• Java只支持单继承，不支持多继承（子类调用父类的不确定性）但是它支持多层继承
• 父类有的子类也有，而且子类可以改变父类的属性值，重写父类的成员方法，父类没有的子类也可以增加
• 父类的属性和方法可以继承，但是构造放噶不能继承，子类的构造方法隐式的调用父类的无参构造方法，当父类没有无参构造方法时，子类需要使用super来显示的调用父类的构造方法。

继承后的Fu和Zi的关系

• 遵循就近原则

重写和重载的方法

• 重载：
  • 在同一个类中
  • 方法名相同，参数类表不同
• 重写：
  • 存在于父子类中
  • 方法的声明一致（名称和参数）
  • 子类的访问权限不能低于父类的访问权限
• 注意：
  • 父类中的私有方法不可以被覆盖
  • 在子类覆盖方法中，要想继续使用被覆盖的父类方法可以通过supper.方法名获取。
  • This代表本类对象的引用
  • super代表父类所属的空间，并不是一个对象
• 结论：父类的构造函数，既可以给本类对象初始化，也可以给子类对象初始化。

final

• final修饰的类不能被继承‘
• final修饰的成员变量不能被重写
• final修饰的成员变量是一个常量

抽象方法

• 只有功能声明，没有功能主体的方法称为抽象方法
• 特点：
  • 抽象类和抽象方法都必须用abstract关键字修饰
  • 抽象方法一定要在抽象类中
  • 一个类继承了抽象类，那么该类实现类中的所有抽象方法
• 注意：抽象关键字abstract不可以和final，private.static关键字共存。

接口

• 概述：接口是特殊的抽象类，所有的属性都是公开静态常量（全局常量），所有的方法都是公开的抽象方法而且没有构造方法。
• 特点：
  • 接口是对外暴露的规则
  • 接口是程序功能的扩展
  • 接口的出现降低耦合性
  • 接口可以用来多实现
  • 类与接口之间是实现关系，而且类可以继承一个类的同时实现多个接口。接口与接口之间可以有继承关系。
• 注意：
  • 如果接口默认的方法是Public和abstract可以省略不写，但是类在实现接口时，不可省略public
  • 类实现接口的时候，要么全部实现接口中的方法，要么类本身定义为抽象类，接口不能被实例化，所有成员有固定修饰符。

接口和抽象类的区别？---都是不断向上抽取出来的

• 抽象类只能单继承，接口可以多实现
• 抽象类中可以有非抽象方法。抽象类中可以定义变量和常量。接口中的方法都是抽象方法，接口中只能有静态常量。因为接口中的方法都有默认修饰符：public abstract ;接口中的成员变量都有默认修饰符:Public static final
• 抽象类中定义的是一个体系的共性功能，接口中通常定义的是对象中的扩展功能。
• 接口的出现避免了单继承的局限性
• 抽象类被继承表示的是：is a的关系，叫做：xx是yy的一种。接口被实现表示的是：like a 的关系。叫做xx像yy一种。

多态

• 概述：事物的多种形态，它分为静态多态（重载）和动态多态（对象的多态）
• 特点：
  • 体现
    • 多态用在方法的参数上m(A a)可以用A的任何一个子类对象作为参数
    • 多态用在方法的返回值上，方法的返回值可能是A的子类对象
  • 前提:
    • 类与类（接口）之间有继承（实现）关系
    • 必须有重写
    • 父类引用指向子类对象
  • 多态的成员变量（不理解）
    • 成员变量：编译看左边，运行也看左边
    • 成员方法：编译看左边，运行看右边
    • 静态方法：编译看做边，运行也看左边
  • 好处：提高了代码的扩展性，便于后期可维护性，把不同的子类对象都看成是父类的对象，屏蔽子类差异，使得程序更加通用
  • 弊端：只能使用子类中和父类中同名的方法，对于子类特有的方法试用不了。
  • ClassCastException:在进行子类特有的方法使用时，要进行向下转型，转型前一定要做判断，否则容易发生此异常增强程序的健壮性

异常

throws,throw抛出

区别：一旦执行throw语句，就结束功能

• 使用位置
  • throws在方法的声明上使用
  • throw在方法体内使用
• 使用格式
  • throws后面跟的使用异常的类名
  • throw后面跟的是对象。格式 throw new 异常类名（参数）
• 联系
  • 有throws不一定有throw
  • 有throw一定有throws

Exception的分类

• Exception：这种类型的异常，如果抛出，在编译的时候就会检查，此类异常需要编写针对性的处理代码进行处理。
• RuntimeException：这种类型的异常，如果抛出，在编译的时候不检查，运行的时候直接处理，这种异常必须通过修改代码才能解决，所以一般针对这种异常，我们不处理，jvm处理。

自定义异常

• 继承自Exceptioin或者RunException必须的
• 在自定义异常里面，提供一个带参构造。

class MyException extends Exception{
    MyException(){}
    MyException(String message){
        super(message);
    }
    

测试题

 char 型变量中能不能存贮一个中文汉字？为什么？

答：char 型变量是用来存储 Unicode 编码的字符的，unicode 编码字符集中包含了汉字，

所以，char 型变量中当然可以存储汉字。不过，如果某个特殊的汉字没有被包含在 unicode 编码字符集中，那么，这个 char 型变量中就不能存储这个特殊汉字。(unicode 编码占用两个

字节，所以，char 类型的变量也是占用两个字节。)  静态变量和实例变量的区别？

(1)作用范围

A：静态变量随着类的加载而加载，随着类的消失而消失。生命周期最长。

B：实例变量随着类的创建而加载，对象消失，实例变量消失。

(2)存储空间

A：静态变量存储在方法区中的静态区，被所有实例共享。

B：实例变量存储在堆内存中，只被某一个对象所特有。

(3)调用方式

A：静态变量既可以通过对象名调用，也可以通过类名直接调用。

B：实例变量只能通过对象名调用。

 abstract class 和 interface 有什么区别？

答: A：抽象类只能单继承,接口可以多实现。

B：抽象类中可以有非抽象方法,抽象类中可以定义变量和常量。接口中的方法都是抽象的。

接口中只能有静态常量。接口中的方法都有默认修饰符：public abstract 接口中的成员变

量都有默认修饰符：public static final

C：抽象类中定义的是一个体系的共性功能,接口中通常定义的对象中的扩展功能。

D：接口的出出现避免了单继承的局限性。

E：抽象类被继承表示的是：is a 的关系。叫做：xx 是 yy 的一种。接口被实现表示的是：

like a 的关系。叫做：xx 像 yy 一种。

 面向对象的特性有哪些，分别阐述说明？

(1)抽象：抽象就是忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前

目标有关的方面。抽象并不打算了解全部问题，而只是选择其中的一部分，暂时不用部分细节。

抽象包括两个方面，一是过程(行为)抽象，二是数据(属性)抽象。

(2)继承：继承是一种层次模型，允许和鼓励类的重用，它提供了一种明确表述共性的方法。

对象的一个新类可以从现有的类中派生，这个过程称为类继承。新类继承了原始类的特性，新类62

称为原始类的派生类（子类），而原始类称为新类的基类（父类）。派生类可以从它的基类那里继

承方法和实例变量，并且类可以修改或增加新的方法使之更适合特殊的需要。

(3)封装：封装是把过程和数据包围起来，对数据的访问只能通过已定义的界面。面向对象

计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治、封装的对象，这些对象通过

一个受保护的接口访问其他对象。

(4)多态性：多态性是指允许不同类的对象对同一消息作出响应。多态性包括参数化多态性

(重载)和对象多态性(子父类的重写)。多态性语言具有灵活、抽象、行为共享、代码共享的优

势，很好的解决了应用程序方法同名问题。

转载于:https://www.cnblogs.com/XtsLife/p/11057531.html