命令提示符

切换盘符        盘符名称:
打开文件夹      cd 名称
打开多级菜单    cd 文件夹1\文件夹2\
返回上一级      cd ..
返回根路径      cd \
查看当前内容    dir
清屏            cls
退出cmd         exit

helloe world入门

//第一行的第三个单词必须和所在文件名称完全一致,大小写也一致
//public class后面代表定义一个类的名称,类是java当中所有源代码的基本组成单位

public class HelloWorld{
//第二行是万年不变的内容,代表main方法
//代表程序执行的起点
    public static void main(String[] args){
//第三行代表 打印输出
        System.out.println("hello World");
    }
}

注释 //单行注释  /* 多行注释*/

关键字

定义: 有特殊含义的,被保留的,不能随意使用的字符。

特点:
        1.完全小写的字符
        2.在增强版的记事本(notpad++),有特殊标记颜色

标识符

定义:是指在程序中,我们自己定义的内容,比如类的名字方法的名和变量的名字等等,都是标识符。

命名规则:[硬性要求]

        标识符可以包括 英文26个字母(区分大小写)、0-9数字、$美元符号和_下划线
        标识符不能以数字开头
        标识符不能是关键字
        
命名规则:[软性要求]
        类名规范:首字母大写,后面每个单词首字母大写(大驼峰式)
        变量名规范:首字母小写,后面每个单词首字母大写(小驼峰式)
        方法名规范:同变量名。

常量

常量的分类:

1.字符串常量:范时勇双引号引起来的部分叫做字符串常量。   例:"abc"、"123"、"hello"
    2.整数常量:直接写上的数字  例:1、3、55、6
    3.浮点数常量:直接写上的数字,但是有小数点    例: 1.2、3.14、-6.66
    4.字符常量:凡是用单引号引起来的单个字符   例:'5'、'你'、'A'
    5.布尔常量:只有两种取值 true 和 false
    6.空常量: null 代表没有任何数值

常量的打印输出

public class javatest{
     public static void main(String[] src){
     //字符串常量
     System.out.println("ABC");
     //整数常量
     System.out.println(50);
     System.out.println(-50);
     //浮点数常量
     System.out.println(3.14);
     System.out.println(-6.66);
     //字符常量
     System.out.println('a');
     //字符常量不可出现内容为空  有且只有一个字符
     //布尔常量
     System.out.println(true);
     System.out.println(false);
     //空常量  不能直接打印输出
     /////////////////////////
    }
}


数据类型

基本数据类型

整数型 byte short int long
    浮点型 float double
    字符型 char
    布尔型 boolean

数据类型大小

基本类型大小取值范围
int4个字节-2^31 ~ 2^31-1
char2个字节
byte1个字节-2^7 ~ 2^7-1
short2个字节-2^15 ~ 2^15-1
long8个字节-2^63 ~ 2^63-1
float4个字节
double8个字节
boolean1或者4个字节true ~ false

引用数据类型

字符串
    数组
    类
    接口
    Lambda

注意事项

1.字符串不是基本类型,而是引用类型
2.浮点数可能只是一个近似值,并非精确得值
3.数据范围与字节数不一定相关,例如float数值范围就比long更加广泛,但是float是4字节,long是8字节
4.浮点数当中的默认是double,如果一定要使用float类型,需要加上一个后缀F。
  如果是整数,默认为int类型,如果一定要使用long类型,需要加上后缀L。

变量

定义:程序运行期间,内容可以发生改变的量
创建格式:数据类型 变量名称 //创建了一个变量
变量名称 = 数据值; // 将右边的数据值,赋值给左边的变量
一步到位格式:
数据类型 变量名称 = 数据值; //在创建变量时,立刻放入指定的值;

注意事项

1.如果创建多个变量,那么变量之间的名称不可以重复。
    2.对于float和lonng类型的变量,后缀F和L不要丢掉。
    3.如果使用byte或者short类型的变量,那么右侧的数据值不能超过左侧类型的范围
    4.没有进行赋值的变量,不能直接使用,一定要赋值以后才能使用。
    5.变量的使用不能超过作用域的范围
      【作用域】:从定义变量的一行开始,直至所有的大括号结束为止。
    6.可以通过一条语句创建多个变量,但是不推荐

数据类型转换

当数据类型不一样时,将会发生数据类型转换

自动字符转换(隐式)

1.特点:代码不需要进行特殊处理,自动完成
    2.规则:数据范围从小到大

强制字符转换(显式)

1.特点:代码需要进行特殊的格式处理,不能自动完成
    2.规则:范围小的类型 范围小的变量名 = (范围小的类型)原本范围大的数据;

注意事项

1.强制类型转换一般不推荐使用,因为有可能发生精度损失,数据溢出
    2.byte/short/char 这三种类型都可以发生数学运算,例如加法‘+’
        (一旦 char 类型进行了数学运算,那么字符就会通过一定规则翻译成数组)
    3.byte/short/char 这三种类型在运算的时候都会被首先提升成为int类型,然后在计算。
    4.Boolean(布尔类型)不能发生数据类型转换。

运算符

进行特定操作的符号。
表达式:用运算符连起来的式子叫表达式

四则运算

加:+
        加法的三种用法
                1.对于数值来说,就是加法
                2.对于字符char类型来说,在计算之前,char将会被提升为int类型在计算。
                3.对于字符串String(首字母大写,并不是关键字)来说,加好代表字符串连接操作。任何数据类型和字符串进行连接时,结果都会变成字符串。
    减:-
    乘:*
    除:/
    取模(取余数):%

注意事项

1.一旦运算中有不同类型的数据,那么结果将会是数据类型范围大的那种

自增自减运算符

自增运算符:++
自减运算符:--

赋值运算符

赋值运算符含义
=等于
+=加等于
-=减等于
*=乘等于
/=除等于
%=取模等于

注意事项

1.只有常量才能使用赋值运算符,常量不能进行转换。
    2.符合赋值运算符其中隐含了一个强制类型转换。

比较运算符

比较运算符含义
==比较符号两边数据是否相等,相等结果是true。
<比较符号左边的数据是否小于右边的数据,如果小于结果是true。
>比较符号左边的数据是否大于右边的数据,如果大于结果是true.
< =比较符号左边的数据是否大于或者等于右边的数据,如果小于结果是true。
> =比较符号左边的数据是否大于或者等于右边的数据,如果小于结果是true。
!=不等于符号,如果符号两边的数据不相等,结果是true。
.equals()将字符串与指定的对象比较

注意事项

1.比较运算符的结果一定是一个boolean值,成立就是true, 不成立就是false
    2.如果进行多次判断,不能连着写。

逻辑运算符

逻辑运算符含义中文含义
与(并且)&&全都是true,才是true;否则就是false
或(或者)II至少一个是true,就是true; 全都是false, 才是false
非(取反)本来是true,变成false; 本来是false, 变成true

注意事项

1.逻辑运算符只能用于boolean值。
2.与、或需要左右各自有一个boolean值,但是取反只要有唯一的一个boolean值即可。
3.与、或两种运算符,如果有多个条件,可以连续写。
  两个条件:条件A &&条件B
  多个条件:条件A &&条件B &&条件C
TIPS:
对于1 < x < 3的情况,应该拆成两个部分,然后使用与运算符连接起来:
int x=2;
1 < x && x < 3

三元运算符

格式:数据类型 变量名称 = 条件判断?表达式A :表达式B;
流程:
    首先判断条件是否成立:
    如果成立为true, 那么将表达式A的值赋值给左侧的变量; .
    如果不成立为false, 那么将表达式B的值赋值给左侧的变量: .
    二者选其一。

注意事项

1.必须同时保证表达式A和表达式B都符合左侧数据类型的要求。
    2.三元运算符的结果必须被使用。

方法

定义:定义一个方法的格式:
    public static void 方法名称() {
        方法体
    }
    方法名称的命名规则和变量-样,使用小驼峰。
    方法体:也就是大括号当中可以包含任意条语句。|

方法的三种调用方式

1.单独调用  方法名称(参数)
2.打印调用  System.out.println(方法名称(参数))
3.赋值调用  数据类型 变量名称 = 方法名称(参数)

注意事项

1.方法定义的先后顺序无所谓
    2.方法的定义不能产生嵌套包含关系
    3.方法定义好了后,不会执行。如果要执行一定要调用。
    
方法调用:方法名称();

方法重载(Overload)

对于功能类似的方法来说,因为参数列表不一样,却需要记住那么多不同的名称很麻烦
    
方法的重载(Overload):多个方法的名称一样,但是参数列表不同
优点:只需要记住一个方法名称,就可以实现类似的功能

注意事项

方法重载与下列因素有关:
    1.参数个数不同
    2.参数类型不同
    3.参数的多类型顺序不同
方法重载与下列因素无关:
     1.与参数的名称无关
     2.与方法的返回值类型无关

方法重写

两个存在继承关系的类
子类重写方法名,参数列表相同才成为重写
返回值相同
子类重写的方法不允许比父类更加严格

构造方法

构造方法名与类名相同  并且没有返回值 

new 构造方法名 直接调用
    
public 构造方法名(){
}

流程

循序结构

判断语句

单if语句

if(关系表达式){
    语句体;
}
执行流程
首先判断关系表达式看起结果是true还是flash。
    结果为true时,执行语句体。
    结果为flash时,跳过语句体。

if...else

if(关系表达式){
    语句体1;
}else{
    语句体2;
}
执行流程
首先判断关系表达式看其结果是true还是false
    如果是true就执行语句体1
    如果是false就执行语句体2

if...else if ...else

if (判断条件1) {
    执行语句1;
} else if (判断条件2) {
    执行语句2;
} else if (判断条件n) {
    执行语句n; 
} else {
  执行语句n+1;
  }

执行流程
首先判断关系表达式1看其结果是true还是false
    如果是true就执行语句体1
    如果是false就继续判断关系表达式2看其结果是true还是false
    如果是true就执行语句体2
    如果是false就继续判断关系表达式..看其结果是true还是false

选择语句

switch(表达式) {
    case常量值1:
        语句体1;
        break; //立即结束
    case常量值2:
        语句体2;
        break;
    default:
        语句体n+1;
        break;   //可以省略,但是不建议。
}
执行流程
首先计算出表达式的值
     其次,和case依次比较,一旦有对应的值,就会执行相应的语句,在执行过程中,遇到break就会结束。
     最后,如果所有的case都和表达式的值不匹配,就会执行default语句体部分, 然后程序结束掉。
注意事项
多个case后面的数值不可重复
    switch后面的小括号只能是下列数据
        基本数据类型:byte/short/char/int
        引用数据格式:String字符串/enum枚举
    switch语句格式可以很灵活,前后顺序可以颠倒,break语句还可以省略。

循环语句

1.初始化语句:在循环开始最初执行,而且只做唯一-- 次。
2.条件判断:如果成立,则循环继续;如果不成立,则循环退出。
3.循环体:重复要做的事情内容,若干行语句。
4.步进语句:每次循环之后都要进行的扫尾工作。

for

for(初始化表达式;布尔表达式;步进表达式){
    循环体
}

while循环

初始化表达式
    while(条件判断){
        循环体;
        步进表达式;
    }

do-while循环

初始化表达式
do{
    循环体
    步进表达式
}while(条件判断);

三种循环的区别

如果条件判断从来没有满足过,那么for循环和while循环将会执行0次,但是do-while循环会执行至少一次。
for循环的变量在小括号当中定义,只有循环内部才可以使用。while循环和do -while循环初始化语句本来就在外面,所以出来循环之后还可以继续使用。

控制循环

break

一旦执行整个循环语句立刻结束,打断循环
注意事项
1.可以用在switch语句当中,一旦执行,整个switch语句立刻结束。
    2.还可以用在循环语句当中,-一旦执行,整个循环语句立刻结束。打断循环。

continue

一旦执行立即跳过当前次循环,马上开始下一次循环

IDEA

IDEA常用快捷键

快捷键功能
Alt+Enter导入包,自动修正代码
Ctrl+Y删除光标所在行
Ctrl+D复制光标所在行的内容,插入光标位置下面
Ctrl+Alt+L格式化代码
ctrl+/单行注释,再按取消注释
Ctrl+Shift+/选中代码注释,多行注释,再按取消注释
Alt+Ins自动生成代码,toString, get, set等方法
Alt+Shift+.上下箭头移动当前代码行

数组

概念:    数组是一种容器,可以存放多个数值
特点:
    1.数组是一种引用数据类型
    2.数组当中的多个数据,类型必须统一
    3.数组的长度在程序运行期间不允许改变

数组的初始化

数组的初始化:在内存中创建一个数组,并且向其中赋予一些默认值

两种常见的初始化方式:
1.动态初始化(指定长度)
2.静态初始化(制定内容)

动态初始化数组的格式

数据类型[]数组名称 = new 数组类型[数组长度]
解析含义:
    左侧数据类型:也就是数组中保存的数据,全部是统一格式
    左侧数组名称:给数组取一个名字
    右侧的new:代表创建数组的动作
    右侧数据类型:必须和左边的数据类型保持一致
    右侧中括号的长度;也就是数组当中,到底可以保存多少个数据,是一个int类型。

静态初始化数组的格式

数据类型[]数组名称 = new 数据类型[]{元素1,元素2,....}
格式写法
静态初始化:数据类型[]数组名称 = {元素1,元素2,....}

注意事项

1.静态初始化没有直接指定长度,但仍然会自动推算的到长度
    2.静态初始化标准格式可以拆分为两个步骤。
    3.动态初始化也可以拆分为两个步骤
    4.静态初始化一旦使用省略格式,就不能拆分为两个步骤了。
使用建议:
如果不确定数组当中的具体内容,用动态初始化;否则,已经确定了具体的内容,用静态初始化。

访问数组

如果直接打印数组名称,得到的是数组对于的内存地址哈希值、
访问数组元素的格式:数据名称[索引值]
索引值:就是一个int数字,代表数组当中的元素编号

使用动态初始化数组的时候,其中的元素将会自动拥有-一个默认值。规则如下:
如果是整数类型,那么默认为0; 
如果是浮点类型,那么默认为0.0;
如果是字符类型,那么默认为'\u0000'; .
如果是布尔类型, 那么默认为false;
如果是引用类型,那么默认为null。

数组作为返回值

一个方法可以有0、1、多个参数:但是只能有或者1个返回值,不能有多个返回值。
如果希望一一个方法当中产生了多个结果数据进行返回,怎么办?
解决方案:使用一个数组作为返回值类型即可。

java内存划分

1.栈(Stack):存放的都是方法中的局部变量
    局部变量:方法的参数,或者是方法{}内部的变量
    作用域:一旦超出作用域,立刻从沾内存当消失
2.堆(Heap) :凡是new出来的东西,都在堆当中。
    堆内存里面的东西都有一个地址值: 16进制
    堆内存里面的数据,都有默认值。规则: 
        如果是整数默认为0
        如果是浮点数默认为0.0
        如果是字符默认为"\u0000'
        如果是布尔默认为false
        如果是引用类型默认为null
3.方法区(Method Area) :存储.class相关信息,包含方法的信息。
4.本地方法栈(Native Method Stack) :与操作系统相关。
5.寄存器(pc Register) :与CPU相关。

面向对象思想的概述

面向过程:当需要实现一个功能的时候,每一个具体的步骤都要亲力亲为,详细处理每一个细节。
面向对象:当需要实现一个功能的时候,不关心具体的步骤,而是找一一个已经具有该功能的人,来帮我做事儿。

类与对象

什么是类

类:是一组相关属性和行为的集合。可以看成是一 类事物的模板,使用事物的属性特征和行为特征来描述该类

现实中,描述一类事物
属性:就是该事物的状态信息。
行为:就是该事物能够做什么。

类与对象的关系

类是对一类事物的描述,是抽象的。
对象是-类事物的实例,是具体的。
类是对象的模板,对象是类的实体。

类的定义

注意事项:
成员变量是直接定义在类当中的,在方法外边。
成员方法不要写static关键字。

public class ClassName {
//成员变量
//成员方法
}

对象的创建及使用

通常情况下,一个类并不能直接使用,需要根据类创建一个对象才能使用

java 特点

封装

将属性和方法进行权限控制

继承

获得父类所有可以获取的属性和方法
关键字 extends 类名
继承是将父类中所有非私有属性和方法继承
java中只允许单继承  多实现
最终父类  Object

多态

一个属性或一个方法或一个类对象,有不同的表现形式

代码块

静态代码块

当前类创建第一次对象时执行,之后不管谁再创建对象都不会执行

访问修饰符

this 当前类的引用对象

接口

接口就是一个公共的规范标准
只要符合标准 就可以通用

接口是一种引用数据类型,接口最重要的内容就是:抽象方法。
关键字:interface

接口规范

接口规范:
    public interface 接口名称{
        //接口内容;
}

/*在任何版本的java中,接口都能定义抽象方法。
  格式:
      public abstract 返回值类型 方法名称(参数列表);
      public abstract 可省略不写
 */

接口使用步骤

1.接口不能直接使用,必须有一个实现类来实现该接口。
格式:
    public class 实现类名称 implements 接口名称{
    //
}
2.接口的实现类必须覆盖重写(实现)接口中所有的抽象方法。
实现:去掉abstract关键字加上方法体大括号。
3.创建实现类的对象,进行使用。

使用:
/*
如果实现类并没有覆盖重写接口的所有抽象方法,那么这个实现类自己必须就是抽象类
    不能直接new接口对象使用
    创建实现类的对象使用  
*/
关键字:interface
接口中允许存在方法 不允许存在方法体 允许存在属性 但是全部都为静态常量
关键字 implements  接口实现
规范接口:public abstract void test1(int i)
关键字 abstract(抽象)
抽象方法被继承时,必须被实现(重写)

接口与接口的关系  继承 extends  可继承多个接口

个人理解:规范接口就是定义一个共同的标准  如果要实现这个接口 必须按照这个规矩来 不可缺少也不可多加!

例图

1599098884622.png1599098937207.png

抽象类

抽象类中不一定存在 抽象方法
存在抽象方法的类一定是抽象类

类与抽象类的区别:抽象类可以出现普通类的所有内容 又可以存在抽象方法  他的属性是普通的属性  

为什么有抽象类的存在  因为有一些类的行为已经确定下来了,但是还有一部分没有确认  抽象类就是让这一部分没有确认的再细分下去

接口和抽象类都不允许创建对象 可以有对象 单数不是通过new创建对象

Data 时间类对象

java中的时间类对象   国际通用标准

常用方法

Data.  
        getTime()   //时间戳   从现在到 1970/01/01 0:0:0:0毫秒
        
  //时间格式化工具  
    SimpleDataFormat        //"yyyy年MM月dd日 HH/hh时mm分ss秒"

日历类

java. util. Calendar类:日历类
Cal endar类是一个抽象类,里边提供了很多操作日历字段的方法(YEAR、MONTH、DAY_ 0F_ MONTH、HOUR )
Calendar类无法直接创建对象使用,里边有一个静态方法叫getInstance(),该方法返回了Calendar类的子类对象
static Calendar getInstance() 使用默认时区和语言环境获得一个日历。
    
    
    public static void main(String[] args) {
    Calendar CaCalendar .getInstance();//多态
    System. out . print1n(C);
}

成员方法

Calendar类的常用成员方法:
Tpublic int get(int field): 返回给定日历字段的值。
public void set(int field, int value): 将给定的日历字段设置为给定值。
public abstract void add(int field, int amount): 根据日历的规则,为给定的日历字段添加或减去指定的时间量。
public Date getTime(): 返回一个表示此Calendar时间值(从历元到现在的毫秒偏移量)的Date对象。
成员方法的参数:
    int field:日历类的字段,可以使用Cal endar类的静态成员变量获取
    public static final int YEAR = 1;年
    public static final int MONTH = 2;月
    public static final int DATE = 5;月中的某一天
    public static final int DAY_ OF_ MONTH = 5; 月中的某-天
    public static final int HOUR = 10;时
    public static final int MINUTE = 12;分
    public static final int SECOND = 13;

向上/向下转型

向上转型

创建子类对象 用父类进行接收

特点

会丢失子类特有的方法和属性

向下转型

创建父类对象 用子类进行接收

特点

可以获得子类特有的属性和方法(需要强行类型转换)

里氏替换原则

所有父类出现的地方都可以使用其子类进行替换

StringBuilder

原理

1599615886187.png

StringBuilder和String可以相互转换: 
    String->StringBuilder:可以使用StringBuilder的构造方法
        StringBuilder(String str) 构造一个字符串生成器,并初始 化为指定的字符串内容。
    StringBuilder->String :可以使用StringBuilder中的toString方法
        public String toString(): 将当前StringBuilder对象转换为String对象。

装箱与拆箱

基本类型与对应的包装类对象之间,来回转换的过程称为”装箱”与"拆箱" :
    ●装箱:从基本类型转换为对应的包装类对象。
    ●拆箱:从包装类对象转换为对应的基本类型。
    
    
    
    装箱:把基本类型的数据,包装到包装类中(基本类型的数据- >包装类)
        构造方法:
            Integer(int value) 构造一个新分配的 Integer 对象,它表示指定的int值。
            Integer(String 5)构造一个新分配的Integer 对象,它表示String 参数所指示的int值。
            传递的字符串,必须是基本类型的字符串,否则会抛出异常"100” 正确
            "a"抛异常
        静态方法:
            static Integer valueOf(int i) 返回一一个表示指定的int值的Integer实例。
            static Integer value0f(String 5)返回保存指定的String 的值的Integer 对象。
            拆箱:在包装类中取出基本类型的数据(包装类- >基本类型的数据)
        成员方法:
            int intValue() 以int类型返回该Integer 的值。

基本类型与字符串类型之间的相互转换

基本类型与字符串类型之间的相互转换
    基本类型->字符串(String)
1.基本类型的值+""
    最简单的方法(工作中常用)
2.包装类的静态方法tostring(参数),不是objec t类的tostring()重载
    static String tostring(int i)返回一个表示指定整数的String 对象。
3. String类的静态方法value0f(参数)
    static String valueof(int i)返回int 参数的字符串表示形式。
    字符串(String)->基本类型
    使用包装类的静态方法parseXXX(”字符串");
    Integer类: static int parseInt(String s)
    Double类: static double parseDouble(String s)
如果输入参数不为数字 会报错; //NumberFormatException

Collection集合

集合概述

●集合:集合是java中提供的一种容器,可以用来存储多个数据。
 
集合和数组既然都是容器,它们有啥区别呢?
●数组的长度是固定的。集合的长度是可变的。
●数组申存储的是同一类型的元素,可以存储基本数据类型值。集合存储的都是对象。而且对象的类型可以不一
致。在开发中一般当对象多的时候,使用集合进行存储。

ArrayList

与数组的区别 :
            数组的长度不可以发生改变 而ArrayList的长度可以改变
            
对于ArrayList来说,有以恶搞尖括号<E>代表泛型
泛型:也就是装在集合当中的所有元素,全部都是统一的什么类型
注意:反省只能是引用类型们不能是基本类型

格式: ArrayList<String> list = new ArrauList<>


注意事项:
对于ArrayList 集合来硕,直接打印得到的不是地址值,而是内容
如果内容为空,得到的是空的中括号:[]

常用操作

//向集合中添加数据需要通过add方法 
例:  list.add()
反例:list.add(100)  //错误写法,因为创建的时候尖括号泛型已经说了是字符串,添加元素就必须是字符串。 
//  通过索引获取元素
例:list.get(索引)//返回值为对应索引的元素
//从集合中删除元素
例:list.remove(索引)//返回值为被删除的元素
//获取集合的长度尺寸,也就是其中元素的个数
例:list.size()//返回值为元素的个数
    
    
    
    
//遍历集合
    
    for(int i = 0 ; i < list.size() ; i++ ){
        System.out.println( list.get( i ) )
    }

存储基本数据

如果希望向集合ArrayList当中存储基本类型数据,必须使用基本类型对应的包装类
ArrayList<Integer> list = new ArrauList<>
list.add(100);
byteByte
shortShort
intInteger
longLong
floatFloat
doublieDouble
charCharacter
booleanBoolean
Last modification:September 15th, 2020 at 07:08 pm