JAVA

最新推荐文章于 2024-05-18 16:42:38 发布

LIUEUX

最新推荐文章于 2024-05-18 16:42:38 发布

阅读量1.1k

点赞数 4

文章标签： java 开发语言后端

本文链接：https://blog.csdn.net/weixin_60475929/article/details/120967819

版权

计算机（硬件：看的见的物理部分；软件：提供看不见的指令）

程序设计：创建或开发软件

硬件：

1khz = 1024hz，1mhz = 1024khz，1Ghz = 1024mhz

存储设备

磁盘驱动器：硬盘永久性存储

光盘驱动器

USB闪存驱动器

内存

比特（bit）和字节（byte）

输入和输出设备

输入设备：键盘，鼠标

输出设备：显示器，打印机

软件开发

软件，即一系列按照特定顺序组织的计算机数据和指令的集合，有系统软件和应用软件

操作系统

人机交互方式

图形化界面（GUI），命令行方式(CLI)------DOS

del *.txt (.txt文件全部删去）

jvm可以使程序在三个不同的操作系统都可执行

jvm是一个虚拟的计算机，具有指令集并使用不同的存储区域。负责执行指令，管理数据，内存，寄存器。

JAVA语言环境的搭建

IDE

层次

Java程序开发三步骤：编写，编译，运行。

Java

//第一行的第三个单词必须与所在的文件名称完全一致，大小写也要一样

//public class后面代表一个类的名称，类是Java当中所有源代码基本组成单位

public class 文件名{

//代表main方法，代表程序执行的起点

public static void main（String[] args）{

//代表打印的输出语句

System. out.println("HelloWorld");

}

关键词&&标识符

关键字特点：1.完全小写字母

2.在增强版的记事本中（例如Notepad++）有特殊颜色

public，class，static，void......

常量&&变量

常量：在程序运行过程中，固定不变的量

常量分类：

1.字符串常量：用双引号引起来的部分，例如"hello"，"abc"

2.整数常量:直接写上的数，无小数点例如：100，200，27

3.浮点数常量：直接写上的数，有小数点例如：2.1，0.0

4.字符常量：单引号引起来的例如：'A','n','9','中'

5.布尔常量：true，false

6.空常量：null （无任何数据）

变量

程序运行期间，内容可以发生改变的量

创建一个变量并且使用的格式：

数据类型变量名称；//创建了一个变量

数据类型变量名称 = 数据值；

（与c一样）

int num1；

num1 = 10；

System.out.printfln(num1);

输出10

long num2 = 10000L;

float num3 = 2.5F；

数据类型

基本数据类型

整数型 byte short int long

浮点型 float double

字符型 char

布尔型 boolean

注意事项：

1.字符串不是基本类型，而是引用类型

2.浮点型可能只是一个近似值，并非准确值

3.数据范围与字节不一定相关，例如：float数据范围比long更加广泛，但是float是4字节，long是8字节

4.浮点数当中默认类型为double，如果一定要使用float类型，需要加上一个后缀F。

如果是整数默认为int类型，如果一定要使用long类型，需要加上一个后缀L。

数据类型转化

自动类型转换（隐式）

特点：代码不需要特殊处理，自动完成

规则：数据类型从小到大

public class Demo01DateType {
      public static void main(String[] args) {
            //int---> long,符合数据类型有小到大的要求
            //这行代码完成了自动类型的转换
            long num1 = 100;     
            System.out.println(num1);
//..................................................
            double num2 = 2.5F;
            System.out.println(num2);

             //左边为float类型，右边为long类型
             //long--> float,范围是float更大一些，，符合从小到大的规则
              float num3 = 30L;
              System.out.println(num3);  //30.0
                                              }
                              }

强制类型转换

1.代码需要进行特殊格式处理，不能自动完成

2.格式：范围小的类型范围小的变量名 = （范围小的类型）原本范围大的类型

public class Demo01DateType {
      public static void main(String[] args) {
            int num = （int) 100L;
            System.out.println(num);
                                                }
                              }

1.不推荐使用，容易造成数据溢出，精度损失

2.byte/short/char这三种类型可以发生数学运算，例如：“+”

3. byte/short/char这三种类型在运算时，都会被提升为int 类型然后再进行运算

4.boolean类型不能发生数据类型转换

****

public class Demo01DateType {
      public static void main(String[] args) {
           char zifu1 = 'A';
            System.out.println(zifu1 + 1); //A被视为65输出
         //一旦char类型进行数学运算，字符会按照一定的规则（ASCII码）翻译成一个数字 
                                                }
                              }
//输出结果为66

运算符

对于字符串String（首字母大写，并不是关键字）来说，加号代表字符串连接操作

public class Demoplus {
        public static void main(String[] args) {
                String str1 = "Hello";
                System.out.println(str1);//Hello
                System.out.println("HEllo" + "World");//HellooWorld


                String str2 = "Java";
                //String + int --> String
                System.out.println(str2 + 20); //Java20
              //优先级问题
               System.out.println(str2 + 20 + 30); //Java2030
                 System.out.println(str2 + （20 + 30）); //Java50

                
}
}

public class Demoplus {
        public static void main(String[] args) {
           int num = 20;
            System.out.println(++num);//21
            System.out.println(num);//21
            int num1 =30;
            System.out.println(num1++);//30
            System.out.println(num1);//31



             int num2 = 40;
             int result = x--;
             System.out.println(result);//40
             System.out.println(num2);//39


             int num3 = 50;
             int result1 = --x;
             System.out.println(result1);//49
             System.out.println(num2);//49


            int x = 10;
            int y = 20;
            int result3 = ++x + y--;
            System.out.println(result3);    //11 + 20 = 31
            System.out.println(x);   //11
            System.out.println(y);   //19

                                               }
                      }

&&且 ||或 !非

运算符

一元运算符

只需要一个数据进行操作的运算符 eg：取反！，自增一++，自减--

二元运算符

需要两个变量操作的运算符 eg：加法+，赋值=

三元运算符

需要三个变量操作的运算符

格式：

数据类型变量名称 = 条件判断？表达式A ：表达式B；

流程：首先判断条件是否为成立

如果成立为true，将表达式A的值赋值给左侧的变量

如果不成立为false，那么将表达式B的值赋值给左侧变量

方法初探

就是将一个功能抽取出来，把代码单独定义于一个大括号内，形成一个单独的结构

eg：

可以分为四个方法

方法格式：

public static void 方法名称（） {
        方法体
}
//方法名称的命明规则和变量一样，使用小驼峰
//方法体：也就是在大括号当中可以包含任一条语句

public class DemoMethod {
     public static void main {
            //调用厨子的方法
            cook（)
}
    //农民伯伯
    public static void farmer() {
         System.out.println("播种")；
         System.out.println("浇水")；
         System.out.println("施肥")；
         System.out.println("除虫")；
         System.out.println("收割")；
         System.out.println("卖给小商贩")；
}

    public static void seller() { 
         //小商贩
         System.out.println("运输至农贸市场")；
         System.out.println("抬高价格")；
         System.out.println("吆喝")；
          System.out.println("卖给厨子")；
      }
    public static void cook() {
            //厨子
            System.out.println("洗菜")；
            System.out.println("切菜")；
            System.out.println("炒菜")；
            System.out.println("装盘")；
      }
    public static void me() {
           System.out.println("吃")；
        }

注意事项：

1.方法的定义的先后顺序无所谓

2.方法的定义不能产生嵌套包含模式

3.方法定义好后，不会执行，如果要执行，一定要进行方法的调用

判断语句

（已知次数用for循环，未知用while循环，最少运行一次用do...while循环）

if..语句

if（关系表达式）{

语句体

}

if......else..

if...else if...else

选择结构 ---switch

switch（被检测量）

注意事项

1.多个case后面的数值不可重复

2.switch后面小括号当中只能是下列数据类型

基本数据类型：byte，short，char，int

引用数据类型：String字符串，enum枚举

3.switch语句结构灵活，前后可以颠倒，而且break语句可以省略（不推荐）

循环语句

for循环

while循环

do...while循环

1.循环控制语句

break

直接跳出循环，不执行下面的过程

continue

一旦执行，立刻跳过当前次循环剩余内容，马上开始下一次循环

public class Continue {
    public static void main(String[] args){
        for (int i = 1;i <= 10;i++) {
            if (i == 4) {   //当前是4层
                continue;  //跳出当前循环，马上开始下一次（第五层）

            }
          System.out.println(i+"层到了");
        }


    }
}

死循环标准格式

while（true） {

循环体

}

嵌套循环

public class LoopHourAndMinute {
    public static void main(String[] args){
        for (int hour = 0;hour < 24;hour++) {
            for (int minute = 0;minute < 60;minute++) {
                System.out.println(hour+"点"+minute + "分");
            }

        }


    }
}

方法再探

方法就是若干语句的功能集合

eg：方法好比就是一个工厂

蒙牛工厂：原料：奶牛，饲料，水

产出物：奶制品

参数：就是进入方法的数据

返回值：就是从方法中返回来的数据

定义方法的完整类型

修饰符返回值类型方法名称（参数类型参数名称,.....) {

方法体

return 返回值

}

修饰符 现阶段固定写法 public static

返回值类型 也就是方法产生的数据结果是什么类型

方法名称 ，和变量命名一样使用小驼峰

参数类型：进入方法数据是什么类型

参数名称：进入方法的数据类型对应的变量名称

ps:方法如果有多个，使用都好进行分隔

方法体:方法需要做的事情，若干行代码

return：1.停止当前方法2.将后面的返回值还给调用处

返回值也就是方法结果

注意：return后面的“返回值”，必须和方法名称前面的“返回值类型”，保持一致

方法调用的三种格式

1.单独调用：方法名称（参数）；

2.打印调用：System.out.println(方法名称（参数）)；

3.赋值调用：数据类型变量名称 = 方法名称（参数）；

注意：此前学习的方法，返回值类型固定写为void，这类方法只能够单独调用，不能进行打印调用或者赋值调用

//定义两个int类型数字相加的方法
//返回值类型int
//方法名称：sum
//参数列表：int a,int b
public class Demo02MethodDefine {
        public static void main(String[] args) {
          //单独调用
          sum(a:10,b:20);
           //打印调用
          System.out.println(sum(int a,int b))；
           //赋值调用
          int number = sum(a:15,b:20);
           System.out.println("变量的值" + number);
}
         public static int sum(int a,int b) {
                int result = a + b;
                return result;
            }

判断两数是否相同

注意事项：1.方法应该定义在类当中，但是不能在方法当中再定义方法。不能嵌套

2.方法定义的前后顺序无所谓

3.方法定义之后不会执行，如果希望执行，一定要调用：单独调用，打印调用，赋值调用

4.如果方法有返回值，那么必须写上“return 返回值;",不能没有

5.return后面的返回值类型，必须和方法返回值类型，对应起来

6.对于一个void没有返回值的方法，不能写return后面的返回值，只能写return自己（return;）

7.对于方法当中最后一行的return可以省略不写

8.一个方法中可以有多个return语句，但是必须保证同时只有一个会被执行到，两个return不能连写

一个方法中返回多个结果数据

利用数组

public class Demo02ArrayReturn{
    public static void main(String[] args) {
        int[] result = calculate(10,20,30);
        System.out.println("总和是" + result[0]);
        System.out.println("平均数是" + result[1]);
    }
    public static int[] calculate(int a,int b,int c) {
        int sum =a + b + c;
        int avg = sum/3;
        int[] array = new int[2];
        array[0] = sum;
        array[1] = avg;
        //int[] array = {sum,avg};

        return array;
    }
}

方法重载（Overload）

多个方法名称一样，但是参数列表不同

好处：只需记住唯一一个方法的名称，就可以实现类似的多个功能

方法重载与下列因素有关

1.参数个数不同

2.参数类型不同

3.参数多类型顺序不同

方法重载与下列因素无关

1.与参数名称无关

2.与方法的返回值类型无关

数组

概念：是一种容器，可以存放多个数据值

特点：1.数组是一种引用数据类型

2.数组当中的多个数据，类型必须统一

3.数组的长度在程序运行期间不可改变

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

两种方式：1.动态初始化

数据类型[] 数组名称 = new 数据类型[数组长度]；

int arrayB = new int[5];

//标准格式可以拆分为两个步骤

int arrayB[];

arrayB = new int[5];

解析含义：

左侧数据类型：也就是数组当中保存的数据，全都是统一的什么类型

左侧中的括号：代表我是一个数组

左侧的数组名称：给数组起一个名字

右侧的new：代表创建数组的动作

右侧的数据类型：必须和左侧的数据类型一致

右侧中括号长度：也就是数组中，到底存放了多少数据，是一个int数字

2.静态初始化：在创建数组时不直接指定数据个数多少，而是直接将具体的数据内容进行指定

数据类型[] 数组名称 = new 数据类型[] {元素1，元素2，...};

int[] arrayB = new int[]{11,12,13};

//标准格式可以拆分为两个步骤

int [] arrayA;

arrayA = new int[] {11,12,13};

//省略格式：数组类型[] 数组名称 = {元素1，元素2，...};

注意事项

虽然静态初始化没有告诉长度，但是根据大括号里面元素具体内容，也可以推算出来长度

使用建议：

如果不确定数组中的具体内容，用动态初始化；否则，已经确定了具体内容，用静态初始化

使用数组元素

直接打印数组名称，得到的是数组对应的：内存地址哈希值

访问数组元素格式：数组名称[索引值]

【注意】索引值从0开始，一直到“数组的长度-1”为止

数组长度

public class Demo03ArrayLength {
    public static void main(String[] args) {
            int[] arrayA = new int[3];
            int[] arrayB ={10,20,20,1,5,4,87,82,6,5,49,54,5};
            int len = arrayB.length;
            System.out.println("arrayB数组长度为" + len);
}
}

数组一旦创建，程序运行期间，长度不可改变

//仅仅改变了地址，旧地址的数组仍为3

JAVA的内存需要划分5个部分

1.栈（Stack）：存放的是方法中的局部变量方法运行一定要在栈中

局部变量：方法的参数，或者是方法{}内部的变量

作用域：一旦超过作用域（大括号），立刻从栈内存当中消失

2.堆（Heap）：凡是new出来的东西，都在堆当中

堆内存里面的东西只有一个地址值：16进制

堆内存里面的数据，都i有默认值，规则：

3.方法区（Method Area）：存储.class相关信息，包含方法的信息。

4.本地方法栈（Native Method Stack）：与操作系统相关

5.寄存器（pc Register）:与CPU相关

两个数组时

int[] arrayB = arrayA;//将arrayA数组的地址值，赋值给arrayB数组

数组遍历

package lxjava;

public class Day01 {
    public static void main(String[] args) {
        int array[] = {10, 20, 30, 50};
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }
}

数组元素反转（与快速排序原理基本一致）