Java基础总结

数据类型

• 强类型语言：要求变量的使用要严格符合规定，所有变量都必须先定义后才能使用

基本类型

数值类型

1. 整数类型：
2. byte占1个字节范围
3. short占2个字节范围
4. int占4个字节范围
5. long占8个字节范围
6. 浮点类型：
7. float占4个字节
8. double占8个字节
9. 字符类型char占2个字节

boolean类型

• 占1位，只有true和false两个

引用类型

• 类
• 接口
• 数组

类型转换

• 由于java是强类型语言，所有要进行有些运算的时候，需要用到类型转换
• 运算中，不同类型的数据先转化为同一类型，再进行运算
  注意：

1. 不能对布尔值进行转换
2. 不能把对象类型转换为不相干的类型
3. 在把高容量转换到低容量的时候，强制转换
4. 转换的时候可能会存在内存溢出，或者精度问题！

变量

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

注意事项：

1. 每个变量都有类型，类型可以是基本类型，也可以是引用类型
2. 变量名必须是合法的标识符
3. 变量声明是一条完整的语句，因此每一个声明都必须以分号结束

变量作用域

• 类变量
• 实例变量：从属于对象；如果不自行初始化，那么会返回这个类型的默认值：
  • 数值：0;
  • 字符串：null;
  • 布尔值：false;
  • 除了基本类型，其余的默认值都是null
• 局部变量

public class Variable{
    static int a1 = 0; //类变量
    String str = "hello,world"; //实例变量
    
    public void method{
        int i = 0; //局部变量
    }
}

常量

• 常量：初始化后不能再改变值！不会变动的值
• 所谓常量可以理解成一种特殊的变量，它的值被设定后，在程序运行过程中不允许被改变

final 常量名 = 值
final double PI = 3.14

• 常量名一般使用大写字符

运算符

字符串连接符 +

int a = 10;
int b = 20;
System.out.println(""+a+b); //1020
System.out.println(a+b+"");  //30

包机制

• 为了更好地组织类，Java提供了包机制，用于区别类名的命名空间
• 一般利用公司域名倒置作为包名
• 为了能够使用某一个包的成员，我们需要在Java程序中明确导入该包，使用import 语句可完成此功能

JavaDoc

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

参数信息

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

命令行

javadoc 参数 Java文件

IDEA生成JavaDoc

• 第一步：选择生成JavaDoc文档的范围，我只对一个源文件生成Doc，所以选择文件。
• 第二步：输出目录最好新建一个文件夹，比较有条理和整洁
• 第三步：区域设置，决定文档的语言，简体中文就是zh_CN、繁体(台湾)zh_tw、繁体(香港)zh-hk、英语(香港)en-hk、英语(美国)en-us、英语(英国)en-gb、英语(全球)en-ww
• 第四步：其他命令行参数：如果区域设置为中国，参数一般为-encoding UTF-8 -charset UTF-8
• 第五步：设置完成后点击确定即可生成Doc文档

流程控制

用户交互Scanner

• 类似与C语言中的scanf
• 我们可以通过Scanner类来获取用户的输入
• 基本语法：

Scanner s = new Scanner(System.in);

• 通过Scanner类的next()与nextLine()方法获取输入的字符串，在读取前我们一般需要使用hasNext()与hasNextLine()判断是否还有输入的数据

next()

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

nextLine()

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

顺序结构

• Java的基本结构就是顺序结构，除非特别指明，否则就按照顺序一句一句执行
• 顺序结构是最简单的算法结构

选择结构

if单选择结构

if(布尔表达式){
//如果布尔表达式的值为true
}

if双选择结构

if(布尔表达式){
    //如果布尔表达式的值为true  
}else{
    //如果布尔表达式的值为false
}

if多选择结构

if(布尔表达式1){
    //如果布尔表达式1的值为true  
}else if(布尔表达式2){
    //如果布尔表达式2的值为false
}else if(布尔表达式3){
    //如果布尔表达式3的值为false
}else{
    //如果以上布尔表达式都不为true执行代码
}

switch多选择结构

switch(expression){
    case value:
        //语句
        break; //可选
    case value:
        //语句
        break; //可选
    //你可以有任意数量的case语句
    default:  //可选
        //语句
}

switch语句中的变量类型可以是：

• byte、short、int或者char
• 从Java SE7开始，switch支持字符串String类型了
• 同时case标签必须为字符串常量或者字面量

循环结构

while循环

while(布尔表达式){
    //循环内容
}

do…while循环

- 至少会执行一次
do{
    //代码语句
}while(布尔表达式)

do…while与while的区别：

• while先判断后执行，do…while是先执行后判断
• do…while总是保证循环体会被至少执行一次，这是他们的只要差别

for循环

• for循环执行的次数是在执行前就确定的
• for循环是最有效、最灵活的循环结构

for(初始化;布尔表达式;更新){
    //代码语句
}

增强for循环

for(声明语句 : 表达式)
{
    //代码句子
}

• 声明语句：声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等
• 表达式：表达式是要访问的数组名，或者是返回值为数组的方法

break 与 continue

• break在任何循环语句的主体部分，均可用break控制循环的流程。break用于强行退出循环，不执行循环中剩余的语句。
• continue语句用在循环语句中，用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定。

标签

• “标签”是指后面跟一个冒号的标识符，例如：label:
• 对java来说唯一用到标签的地方是在循环语句之前。而在循环之前设置标签的唯一理由是：我们希望在其中嵌套另一个循环，由于break和continue关键字通常只中断当前循环，但若随同标签使用，它们就会中断到存在标签的方法。

public class LabelDemo {
    public static void main(String[] args) {
        //打印101~150之间的所有质数
        int count = 0;
        //标签：
        outer:for(int i =101;i<150;i++){
            for(int j =2;j<i/2;j++){
                if(i%j==0){
                    continue outer;
                }
            }
            System.out.print(i+" ");
        }
    }
}

equals和==的区别

1. equals：

• 用于比较对象的内容是否相等。通常在需要比较对象的实际属性时使用
• 常见的类（String、Integer等）已经重写了equals方法，用于比较内容

3. ==：

• 用于比较基本数据类型的值是否相等
• 用于比较引用是否指向同一个对象
  总结：== 用于比较内存地址或基本数据类型的值，而 equals 用于比较对象的内容

方法

• 设计方法的原则：方法的本意是功能块，就是实现某个功能的语句块的集合。我们设计方法的时候，最好保持方法的原子性，就是一个方法只完成一个功能，这样利于我们后期的扩展
• 定义：java的方法类似于其他语言的函数，是一段用来完成特定功能的代码片段。
• 方法包含一个方法头和方法体

方法的重载

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

可变参数

• jdk1.5开始，Java支持传递同类型的可变参数给一个方法
• 在方法声明中，在指定参数类型后加一个省略号
• 一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它之前声明。

public static void main(String[] args) {
    //调用可变参数的方法
    printMax(10,20,3,42);
}

//可变参数方法
public static void printMax(double... numbers){
    if(numbers.length ==0){
        System.out.println("No argument passed");
        return;
    }
    double result = numbers[0];
    //找出最大值
    for(int i =0;i<numbers.length;i++){
        if(numbers[i] > result){
            result = numbers[i];
        }
    }
    System.out.println("The max value is "+ result);
}

递归

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

数组

• 定义：数组是相同类型数据的有序集合
• 数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成
• 基本特点：
  • 其长度是确定的，数组一旦被创建，它的大小就是不可以改变的
  • 其元素必须是相同类型，不允许出现混合类型
  • 数组中的元素可以是任何数据类型，包括基本类型和引用类型
  • 数组变量属于引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的。

数组的声明创建

• 声明：

dataType[] arrayRefVar;  //首选方法
或者
dataType arrayRefVar[];  //效果相同，但不是首选方法

• Java语言使用new操作符来创建数组，语法如下：
  dataType[] arrayRefVar = new dataType[arraySize];
• 获取数组的长度:
  arrays.length;

如果没有对数组进行赋值，则是该数据类型的默认值

三种初始化

静态初始化

int[] a = {1,2,3};
Man[] mans = {new Man(1,1),new Man(2,2)}; 

动态初始化

int[] a = new int[2];
a[0] = 1；
a[1] = 2;

默认初始化

• 数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。

多维数组

• 多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组
• 二维数组：
  int a[][] = new int[2][6];

内存分析

堆

• 存放new的对象和数组
• 可以被所有的线程共享，不会存放别的对象引用

栈

• 存放基本变量类型（会包含这个基本类型的具体数值）
• 引用对象的变量（会存放这个引用在堆里面的具体地址）

方法区

• 可以被所有的线程共享
• 包含了所有的class和static变量

面向对象

面向对象思想

• 物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索
• 面向对象适合处理复杂的问题，适合处理需要多人协作的问题！
• 对于描述复杂的事物，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象的思路来分析整个系统，但是具体到微观操作，仍然需要面向过程的思路去处理

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

• 面向对象编程的本质就是：以类的方式组织代码，以对象的组织（封装）数据
• 三大特性：
  • 封装
  • 继承
  • 多态
• 从认识论角度考虑是先有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象
• 从代码运行角度考虑是先有类后有对象。类是对象的模版

创建与初始化对象

• 使用new关键字创建对象
• 使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用
• 类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的，并且构造器有以下两个特点：
  1. 必须和类的名字相同
  2. 必须没有返回类型，也不能写void

public class Person {
    //一个类即使什么都不写，它也会存在一个方法
    //显示的定义构造器
    String name;
    int age;
    //1、使用new关键字，本质是在调用构造器
    //2、用来初始化值

    public  Person(){
        this.name = "zhengbo";
    }

    //有参构造：一旦定义了有参构造，无参就必须显示定义
    public Person(String name){
        this.name = name;
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

封装

• 属性私有，get/set
• 数据的隐藏：通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏

继承

• 继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模
• extends的意思是“扩展”，子类是父类的扩展
• java中类只有单继承，没有多继承
• 继承是类与类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等
• 继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示
• 子类和父类之间，从意义上将应该具有“is a”的关系
• object类
• Super
• 方法重写
  在java中，所有的类都默认直接或者间接继承Object类
• 私有的东西无法被继承

public class student extends Person{
    public student(){
        //隐藏代码：调用了父类的无参构造
        super(); //调用父类的构造器，必须要在子类构造器的第一行
        System.out.println("studeng无参执行了");
    }
}

Super

super注意点

1. super调用父类的构造方法，必须在构造方法的第一个
2. super必须只能出现在子类的方法或者构造方法中
3. super和this不能同时调用构造方法

super与this的比较

代表的对象不同

• this：本身调用者这个对象
• super：代表父类对象的应用

前提不同

• this：没有继承也可以使用
• super：只能在继承条件下才能使用

构造方法不同

• this()：本类的构造
• super()：父类的构造

重写

• 需要有继承关系，子类重写父类的方法

1. 方法名必须相同
2. 参数列表必须相同
3. 修饰符：范围可以扩大但不能缩小：public>Protected>Default>private

• 为什么需要重写：父类的功能，子类不一定需要，或者不一定满足

多态

• 同一个方法可以根据发送对象的不同而采用多种不同的行为方式
• 一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多
• 多态存在的条件：
  • 有继承关系
  • 子类重写父类方法
  • 父类引用指向子类对象

注意：多态是方法的多态，属性没有多态性