Java基础记录

Java基础

1、标识符命名规则

标识符可以由字母、数字、卞划线(_)和美元符($）组成，不能以数字开头
标识符严格区分大小写
标识符不能是Java关键字和保留字。标识符的命名最好能反映出其作用

2、关键字

总共有50多个关键字
abstract
boolean
break
byte
case
catch
char
class
continue
default
do
double
else
extends
false
final
finally
float
for
if
implements
import
native
int
interface
long
instanceof
new
null
package
private
protected
public
return
short
static
super
switch
synchronized this
throw
throws
transient
true
try
void
volatile
while

3、变量

变量的三个元素∶变量类型、变量名和变量值。

变量名命名规则

满足标识符命名规则
符合驼峰法命名规范 尽量简单
做到见名知意
变量名的长度没有限制
因为基本类型是Java语言里的一种内置的特殊数据类型，并不是某个类的对象
给基本类型的变量赋值的方式叫做 字面值

类的命名规则

满足Pascal命名法规范

4、数据类型

boolean的两个值为true和false。true代表真，false代表假。

基本数据类型

一个字节8个二进制位

二进制表示

八进制:以O开头，包括O-7的数字如:037，056
十六进制表示:以Ox或OX开头，包括O-9的数字，及字母a-f ，A-F如∶0x12，Oxabcf，OXABCFF

整型字面值

Java中有三种表示整数的方法∶十进制、八进制、十六进制 如:123，023，0x1357，0X3c，Ox1abcL

变量声明

格式:数据类型变量名;
例:
int n;声明整型变量n
long count ;声明长整型变量count

赋值

使用“=”运算符进行赋值
“=”叫作赋值运算符，将运算符右边的值赋给左边的变量  例: int n;定义int型变量n
n=3;将3赋值给n
可以在定义变量的同时给变量赋值，即变量的初始化  例: int n=3;

变量定义

int octal=037;
//定义int类型变量存放八进制数据.
long longNumber=Oxa2cdf3ffL;
//定义变量存放十六进制长整型数据
short shortNumber=123;
//定义变量存放短整型数据
byte b=10;
//定义变量存放byte类型数据

浮点型字面值

默认情况下表示double类型，也可以在值后加d或D
如:123.43d或123.43D
如表示float类型，则需要在字面值后加f或F
如:23.4f或23.4F

基本数据类型变量存储

-数据类型分为基本数据类型和引用数据类型
-引用数据类型包括数组和类等
-类定义的变量又叫对象

按作用范围分

-类级、对象实例级、方法级、块级
方法级为局部变量

字符型字面值

字符型字面值用单引号内的单个字符表示  如: ‘a’, ‘b’ , '$'
如何定义字符型变量?
char a= 'a';
char ch=65;//因为ASCII码

ASCII码

ASCII ( American Standard Code for InformationInterchange，美国标准信息交换代码)
基于拉丁字母的一套电脑编码系统
主要用于显示现代英语和其他西欧语言

使用7位或8位二进制数组合来表示128或256种可能的字符。
-7位二进制数组合——标准ASCII码
-8位二进制数组合(后128位)——扩展ASCII码

标准ASCII码表示大小写字母、标点符号、美式英语中的控制字符等。

char 最大0 ~ 65535 超过要强制转换

Unicode编码

Unicode编码又称为统一码、万国码
Unicode编码的目标是支持世界上所有的字符集
char c= '\u005d';
Unicode表示法，在值前加前缀\u

布尔类型字面值

布尔值只能定义为true和false。例:boolean b=true;

字符串字面值

双引号引起来的0个或多个字符。
String s=“”;

转义字符

转义字符使用
System.out.print(""+x+'\t'+y+'ln');//如果不加“”则会把它当成是一个表达式进行计算
//System.out.println();//换行
System.out.print(x+","+y);
System.out.println("\n\'"+x+"\'");

类型转换

类型转换分为自动类型转换和强制类型转换

强制类型转换

如果A类型的数据表示范围比B类型大，则将A类型的值赋值给B类型，需要强制类型转换
如: double d =123.4;
float f=(float)d;
强制数据类型转换的格式:(数据类型)数值
精度高的数据类型就像容量大的杯子，可以放更大的数据
精度低的数据类型就像容量小的杯子，只能放更小的数据
小杯子往大杯子里倒东西，大杯子怎么都放得下
大杯子往小杯子里倒东西，有的时候放的下，有的时候就会有溢出
需要注意的一点是
虽然short和char都是16位的，长度是一样的
但是彼此之间，依然需要进行强制转换

常量

final int n=5;

作用域

当一个变量被声明在类下面
变量就叫做字段 或者属性、成员变量、Field
比如变量i,就是一个属性。
所以其作用域就是从其声明的位置开始的整个类

如果一个变量，是声明在一个方法上的，就叫做参数
参数的作用域即为该方法内的所有代码
其他方法不能访问该参数
类里面也不能访问该参数

声明在方法内的变量，叫做局部变量
其作用域在声明开始的位置，到其所处于的块结束位置

package birenyin.javabasic.pojo;

/**
 * @ClassName HelloWorld
 * @Description TODO
 * @Author Birenyin
 * @Date 2022/5/5 15:53
 * @Version 1.0
 **/
public class HelloWorld {
	int i = 1;
	int j = i;  //其他的属性可以访问i
	public void method1(){
		System.out.println(i); //方法1里可以访问i
		int i  = 5;  //其作用范围是从声明的第4行，到其所处于的块结束12行位置
		System.out.println(i);
		{            //子块
			System.out.println(i); //可以访问i
			int j = 6;
			System.out.println(j); //可以访问j
		}
		System.out.println(j); //不能访问j,因为其作用域到第10行就结束了
	}
	public void method2(){
		System.out.println(i); //方法2里可以访问i
	}
	public void method1(int i){ //参数i的作用域即方法method1
		System.out.println(i);
	}
	public void method3(){

		System.out.println(i); //method3 不能访问参数i
	}
}

final

final 修饰一个变量，有很多种说法，比如不能改变等等
准确的描述是 当一个变量被final修饰的时候，该变量只有一次赋值的机会

public class HelloWorld {
 
    public void method1() {
        final int i = 5; 
        i = 10; //i在第4行已经被赋值过了，所以这里会出现编译错误
    }
 
}
如果在声明的时候未赋值，那么可以在后面代码进行唯一的一次赋值
    public class HelloWorld {
 
    public void method1() {
        final int i;
         
        i = 10; //i在第4行，只是被声明，但是没有被赋值，所以在这里可以进行第一次赋值
         
        i = 11; //i在第6行已经被赋值过了，所以这里会出现编译错误
         
    }
 
}

块

从{ 开始 到对应的} 结束，即一个块

5、运算符

表达式

表达式由运算符和操作数组成
如︰5
num1
num1+num2
sum = num1+num2

算术运算符
赋值运算符
关系运算符
逻辑运算符
条件运算符
位运算符

算术运算符

算术运算符主要用于进行基本的算术运算，如加法、减法、乘法和除法等。

自增自减运算符

赋值运算符

格式:变量=表达式;
例:int n =3;//将3赋值给变量n。
注意:赋值运算符是从右往左运算!

复合赋值运算符

关系运算符

比较运算符用于判断两个数据的大小，
如大于比较的结果是一个布尔值

例∶
'A' >‘B′结果为false，比较的是两个字符的ASCII值。 5!=6 结果为true，比较两个数值是否相等
true==false结果为false，两个布尔值不相等. float f=5.Of; long l=5; f==l;
结果为true，浮点数与整数进行比较，只要值相等就返回true

条件结构

逻辑运算符

&&运算符又叫短路运算符，如果第一个表达式的值就能决定表达式最后的结果，运算符右边的表达式就不再计算了
&长路与
无论长路与还是短路与
两边的运算单元都是布尔值
都为真时，才为真
任意为假，就为假
区别
长路与 两侧，都会被运算
短路与 只要第一个是false，第二个就不进行运算了

||运算符又叫短路运算符，如果第一个表达式的值就能决定表达式最后的结果，运算符右边的表达式就不再计算了。
|长路或
无论长路或还是短路或
两边的运算单元都是布尔值
都为假时，才为假
任意为真，就为真
区别
长路或 两侧都会被运算
短路或 只要第一个是true的，第二个就不进行运算了

取反!
真变为假
假变为真

异或^
不同，返回真
相同，返回假

位运算符

一个整数的二进制表达
public class HelloWorld {
    public static void main(String[] args) {
        int i = 5;
        String b = (Integer.toBinaryString(i)); // 5的二进制的表达101
        System.out.println(i+" 的二进制表达是: "+b);
    }
}
位或
5的二进制是101
6的二进制是110
所以 5|6 对每一位进行或运算，得到 111->7
    public class HelloWorld {
    public static void main(String[] args) {
         
        int i  =5;
        int j = 6;
         
        System.out.println(Integer.toBinaryString(i)); //5的二进制是101
         
        System.out.println(Integer.toBinaryString(j)); //6的二进制是110
         
        System.out.println(i|j); //所以 5|6 对每一位进行或运算，得到 111->7
    }
}
位与
5的二进制是101
6的二进制是110
所以 5&6 对每一位进行与运算，得到 100->4
    public class HelloWorld {
    public static void main(String[] args) {
         
        int i  =5;
        int j = 6;
         
        System.out.println(Integer.toBinaryString(i)); //5的二进制是101
         
        System.out.println(Integer.toBinaryString(j)); //6的二进制是110
         
        System.out.println(i&j); //所以 5&6 对每一位进行与运算，得到 100->4
 
    }
}
异或
5的二进制是101
6的二进制是110
所以 5^6 对每一位进行异或运算，得到 011->3
一些特别情况：
任何数和自己进行异或 都等于 0
任何数和0 进行异或 都等于自己    
    public class HelloWorld {
    public static void main(String[] args) {
        int i  =5;
        int j = 6;
        System.out.println(Integer.toBinaryString(i)); //5的二进制是 101
        System.out.println(Integer.toBinaryString(j)); //6的二进制是110
        System.out.println(i^j); //所以 5^6 对每一位进行或运算，得到 011->3
         
        System.out.println(i^0);
        System.out.println(i^i);
    }
}
~取非
5 的二进制是 00000101
所以取反即为 11111010
这个二进制换算成十进制即为-6
    
    public class HelloWorld {
    public static void main(String[] args) {
        byte i  =5;
         
        System.out.println(Integer.toBinaryString(i)); //5的二进制是00000101,所以取非即为11111010,即为-6
         
        System.out.println(~i);
         
    }
     
}
左移 右移
左移：根据一个整数的二进制表达，将其每一位都向左移动，最右边一位补0
右移：根据一个整数的二进制表达，将其每一位都向右移动
    public class HelloWorld {
    public static void main(String[] args) {
        byte i  =6;
         
        //6的二进制是110
        System.out.println(Integer.toBinaryString(i));
        //6向左移1位后，变成1100，对应的10进制是12
        System.out.println(i<<1);
        //6向右移1位后，变成11，对应的10进制是3
        System.out.println(i>>1);
    }
     
}
>>>=
示符号，0位正，1为负）无论>>还是>>>都是针对二进制数进行操作的。1、右移运算符>>使指定值的所有位都右移规定的次数。右边移出去的部分扔掉不要，左边空出来的部分用原来的数字填充（这就是所谓的带符号右移）——比如说5，右移后为00000010。——你给的例子，假设x=-12，表示为32位int型就是11111111111111111111111111110100x>>3即带符号右移3位，结果是11111111111111111111111111111101，化为十进制等于-32、>>>与>>唯一的不同是它无论原来的最左边是什么数，统统都用0填充。——比如你的例子，byte是8位的，-1表示为byte型是11111111(补码表示法）b>>>4就是无符号右移4位，即00001111，这样结果就是15。

条件运算符

Java中的条件运算符是三目运算符
语法∶布尔表达式?表达式1:表达式2
当布尔表达式的值为true，则返回表达式1的值，否则返回表达式2的值

运算符的优先级

闰年的判断规则∶能被4整除但不能被100整除的年份，或者能被400整除的年份

6、流程控制

流程控制语句:顺序、选择、循环

 if结构:
-判断条件是布尔类型
-判断条件是一个范围
 switch结构:
-判断条件是常量值
switch可以使用byte,short,int,char,String,enum
注: 每个表达式结束，都应该有一个break;
注: String在Java1.7之前是不支持的, Java从1.7开始支持switch用String的，编译后是把String转化为hash值，其实还是整数

结束当前循环

public class HelloWorld {
    public static void main(String[] args) {
          
        //打印单数    
        for (int i = 0; i < 10; i++) {
             
            for (int j = 0; j < 10; j++) {
                System.out.println(i+":"+j);
                if(0==j%2) 
                    break; //如果是双数，结束当前循环
            }
             
        }
         
    }
}

结束外部循环

使用boolean变量结束外部循环
借助boolean变量结束外部循环
需要在内部循环中修改这个变量值
每次内部循环结束后，都要在外部循环中判断，这个变量的值

public class HelloWorld {
    public static void main(String[] args) {
        boolean breakout = false; //是否终止外部循环的标记
        for (int i = 0; i < 10; i++) {
 
            for (int j = 0; j < 10; j++) {
                System.out.println(i + ":" + j);
                if (0 == j % 2) {
                    breakout = true; //终止外部循环的标记设置为true
                    break;
                }
            }
            if (breakout) //判断是否终止外部循环
                break;
        }
 
    }
}

使用标签结束外部循环

在外部循环的前一行，加上标签
在break的时候使用该标签
即能达到结束外部循环的效果

public class HelloWorld {
    public static void main(String[] args) {
          
        //打印单数    
        outloop: //outloop这个标示是可以自定义的比如outloop1,ol2,out5
        for (int i = 0; i < 10; i++) {
             
            for (int j = 0; j < 10; j++) {
                System.out.println(i+":"+j);
                if(0==j%2) 
                    break outloop; //如果是双数，结束外部循环
            }
             
        }
         
    }
}

7、类和对象

public class Hero {
     
    String name; //姓名
     
    float hp; //血量
     
    float armor; //护甲
     
    int moveSpeed; //移动速度
     public static void main(String[] args) {
        Hero garen =  new Hero();
        garen.name = "盖伦";
        garen.hp = 616.28f;
        garen.armor = 27.536f;
        garen.moveSpeed = 350;
         
        Hero teemo =  new Hero();
        teemo.name = "提莫";
        teemo.hp = 383f;
        teemo.armor = 14f;
        teemo.moveSpeed = 330;
    }  
    
}

类就像一个模板，根据这样一个模板，可以创建一个个的具体的英雄
一个个具体的英雄，就叫一个个的对象
new Hero() 就是java中创建一个英雄对象的意思
类的第一个字母大写，更为规范

引用

引用的概念，如果一个变量的类型是 类类型，而非基本类型，那么该变量又叫做引用。

继承

方法重载

构造方法

this

传参

包

访问修饰符

类属性

类方法

属性初始化

单例模式

单例模式又叫做 Singleton模式，指的是一个类，在一个JVM里，只有一个实例存在。
1. 构造方法私有化
2. 静态属性指向实例
3. public static的 getInstance方法，返回第二步的静态属性

饿汉模式

package charactor;
 
public class GiantDragon {
 
    //私有化构造方法使得该类无法在外部通过new 进行实例化
    private GiantDragon(){
         
    }
    //准备一个类属性，指向一个实例化对象。 因为是类属性，所以只有一个
    private static GiantDragon instance = new GiantDragon();
     
    //public static 方法，提供给调用者获取12行定义的对象
    public static GiantDragon getInstance(){
        return instance;
    }
     
}

懒汉模式

package charactor;
 
public class GiantDragon {
  
    //私有化构造方法使得该类无法在外部通过new 进行实例化
    private GiantDragon(){       
    }
  
    //准备一个类属性，用于指向一个实例化对象，但是暂时指向null
    private static GiantDragon instance;
      
    //public static 方法，返回实例对象
    public static GiantDragon getInstance(){
        //第一次访问的时候，发现instance没有指向任何对象，这时实例化一个对象
        if(null==instance){
            instance = new GiantDragon();
        }
        //返回 instance指向的对象
        return instance;
    }
      
}

什么时候使用饿汉式，什么时候使用懒汉式
饿汉式是立即加载的方式，无论是否会用到这个对象，都会加载。
如果在构造方法里写了性能消耗较大，占时较久的代码，比如建立与数据库的连接，那么就会在启动的时候感觉稍微有些卡顿。

懒汉式，是延迟加载的方式，只有使用的时候才会加载。 并且有线程安全的考量(鉴于同学们学习的进度，暂时不对线程的章节做展开)。
使用懒汉式，在启动的时候，会感觉到比饿汉式略快，因为并没有做对象的实例化。 但是在第一次调用的时候，会进行实例化操作，感觉上就略慢。

看业务需求，如果业务上允许有比较充分的启动和初始化时间，就使用饿汉式，否则就使用懒汉式

枚举类型

枚举enum是一种特殊的类(还是类)，使用枚举可以很方便的定义常量
一个常用的场合就是switch语句中，使用枚举来进行判断
因为是常量，所以一般都是全大写
public enum Season {
    SPRING,SUMMER,AUTUMN,WINTER
}
public class HelloWorld {
    public static void main(String[] args) {
        Season season = Season.SPRING;
        switch (season) {
        case SPRING:
            System.out.println("春天");
            break;
        case SUMMER:
            System.out.println("夏天");
            break;
        case AUTUMN:
            System.out.println("秋天");
            break;
        case WINTER:
            System.out.println("冬天");
            break;
        }
    }
}

8、属性

一个英雄有姓名，血量，护甲等等状态
这些状态就叫做一个类的属性
属性的类型可以是基本类型，比如int整数，float 浮点数
也可以是类类型，比如String 字符串
类属性： 又叫做静态属性
对象属性： 又叫实例属性，非静态属性
如果一个属性声明成类属性，那么所有的对象，都共享这么一个值

9、方法

在LOL中，一个英雄可以做很多事情，比如超神，超鬼，坑队友
能做什么在类里面就叫做方法
有返回的方法，无返回方法应用void
方法的参数
方法的命名 一般都是以动词开头的
类方法： 又叫做静态方法
对象方法： 又叫实例方法，非静态方法
访问一个对象方法，必须建立在有一个对象的前提的基础上
访问类方法，不需要对象的存在，直接就访问

public class Hero {
    String name; //姓名
      
    float hp; //血量
      
    float armor; //护甲
      
    int moveSpeed; //移动速度
 
    //坑队友
    void keng(){
        System.out.println("坑队友！");
    }
     //获取护甲值
    float getArmor(){
        return armor;
    }
    //增加移动速度
    void addSpeed(int speed){
        //在原来的基础上增加移动速度
        moveSpeed = moveSpeed + speed;
    }
}

10、操作符Scanner

需要注意的是，如果在通过nextInt()读取了整数后，再接着读取字符串，读出来的是回车换行:"\r\n",因为nextInt仅仅读取数字信息，而不会读取回车换行"\r\n".
所以，如果在业务上需要读取了整数后，接着读取字符串，那么就应该连续执行两次nextLine()，第一次是取走回车换行，第二次才是读取真正的字符串

import java.util.Scanner;
   
public class HelloWorld {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        int i = s.nextInt();
        System.out.println("读取的整数是"+ i);
        String rn = s.nextLine();
        String a = s.nextLine();
        System.out.println("读取的字符串是："+a);
    }
}

11、Arrays

12、面向对象

三大特性

面向对象编程是利用类和对象编程的一种思想。万物可归类，类是对于世界事物的高度抽象 ，不同的事物之间有不同的关系 ，一个类自身与外界的封装关系，一个父类和子类的继承关系， 一个类和多个类的多态关系。万物皆对象，对象是具体的世界事物，面向对象的三大特征封装，继承，多态。封装，封装说明一个类行为和属性与其他类的关系，低耦合，高内聚；继承是父类和子类的关系，多态说的是类与类的关系。

封装

利用抽象数据类型将数据和基本数据的操作封装在一起，使用构成一个不可分割的独立实体。封装隐藏了类的内部实现机制，可以在不影响使用的情况下改变类的内部结构，同时也保护了数据。对外界而已它的内部细节是隐藏的，暴露给外界的只是它的访问方法。属性的封装：使用者只能通过事先定制好的方法来访问数据，可以方便地加入逻辑控制，限制对属性的 不合理操作；方法的封装：使用者按照既定的方式调用方法，不必关心方法的内部实现，便于使用； 便于修改，增强 代码的可维护性

public class Person {

    private String name;
    private int gender;
    private int age;

    public String getName() {
        return name;
    }

    public String getGender() {
        return gender == 0 ? "man" : "woman";
    }

    public void work() {
        if (18 <= age && age <= 50) {
            System.out.println(name + " is working very hard!");
        } else {
            System.out.println(name + " can't work any more!");
        }
    }
}

继承

继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力。在本质上是特殊~一般的关系，即常说的is-a关系。子类继承父类，表明子类是一种特殊的父类，并且具有父类所不具有的一些属性或方法。从多种实现类中抽象出一个基类，使其具备多种实现类的共同特性 ，当实现类用extends关键字继承了基类（父类）后，实现类就具备了这些相同的属性。继承的类叫做子类（派生类或者超类），被继承的类叫做父类（或者基类）。比如从猫类、狗类、虎类中可以抽象出一个动物类，具有和猫、狗、虎类的共同特性（吃、跑、叫等）。Java通过extends关键字来实现继承，父类中通过private定义的变量和方法不会被继承，不能在子类中直接操作父类通过private定义的变量以及方法。继承避免了对一般类和特殊类之间共同特征进行的重复描述，通过继承可以清晰地表达每一项共同特征所适应的概念范围，在一般类中定义的属性和操作适应于这个类本身以及它以下的每一层特殊类的全部对象。运用继承原则使得系统模型比较简练也比较清晰。
遵循里氏替换原则，子类对象必须能够替换掉所有父类对象

Animal animal = new Cat();

多态

多态指的是类和类的关系，两个类由继承关系，存在有方法的重写，故而可以在调用时有父类引用指向子类对象。多态必备三个要素：继承，重写，父类引用指向子类对象。
分为编译时多态和运行时多态：
编译时多态主要指方法重载
运行时多态指程序中定义的对象引用所指向的具体类型在运行期间才确定
运行时多态有三个条件：
继承
覆盖（重写）
向上转型

public class Instrument {
    public void play() {
        System.out.println("Instument is playing...");
    }
}

public class Wind extends Instrument {
    public void play() {
        System.out.println("Wind is playing...");
    }
}

public class Percussion extends Instrument {
    public void play() {
        System.out.println("Percussion is playing...");
    }
}

public class Music {
    public static void main(String[] args) {
        List<Instrument> instruments = new ArrayList<>();
        instruments.add(new Wind());
        instruments.add(new Percussion());
        for(Instrument instrument : instruments) {
            instrument.play();
        }
    }
}

用继承原则使得系统模型比较简练也比较清晰。
遵循里氏替换原则，子类对象必须能够替换掉所有父类对象

```Java
Animal animal = new Cat();

多态

多态指的是类和类的关系，两个类由继承关系，存在有方法的重写，故而可以在调用时有父类引用指向子类对象。多态必备三个要素：继承，重写，父类引用指向子类对象。
分为编译时多态和运行时多态：
编译时多态主要指方法重载
运行时多态指程序中定义的对象引用所指向的具体类型在运行期间才确定
运行时多态有三个条件：
继承
覆盖（重写）
向上转型

public class Instrument {
    public void play() {
        System.out.println("Instument is playing...");
    }
}

public class Wind extends Instrument {
    public void play() {
        System.out.println("Wind is playing...");
    }
}

public class Percussion extends Instrument {
    public void play() {
        System.out.println("Percussion is playing...");
    }
}

public class Music {
    public static void main(String[] args) {
        List<Instrument> instruments = new ArrayList<>();
        instruments.add(new Wind());
        instruments.add(new Percussion());
        for(Instrument instrument : instruments) {
            instrument.play();
        }
    }
}