JAVA初学者学习笔记

JDL是针对Java开发员的软件工具包    本人下载的是JDK17

IDEA是类似于Pycharm类似的工具    提升了编码效率

JDL与IDEA是使用JAVA编写代码必备的工具插件

利用IDEA创造代码

首先需要先创建模组   此处的模组为testfirstmodule

然后在模组中添加package  名称为com.mab.test01,

这样的话，打开目录文件夹中在testfirstmodule文件夹中就有com/msb/test01文件 

在java中是以类管理我们的代码，于是需要添加java class  添加到上文package下面，名称为HelloWorld如下图所示

在大括号中写psvm（小写）作为快捷键，得到main函数，然后在main函数的大括号中写sout（小写）作为快捷键，在小括号中敲入引号，中间写入想要打印的字符串，得到结果如下：

然后右键进行程序试跑 

小技巧：将鼠标放到想要复制的那一行代码最后，然后键盘ctrl-d便可以实现复制一行，ctrl-y是删除一行代码

注释：

//      ---   用于单行注释

/*      ---   用于多行注释

/**     ---   用于文档注释

使用方法如下图：

忽略大小写的选项，可以帮助更好的识别代码，以防大小写错误导致没有办法识别（亲测有用）

变量实际上一个可操作性的空间，位置是确定的但是里面放什么值不确定，我们可以通过变量名字来访问对应的存储空间，从而操控之歌空间存储的值，java是一种强类型语言，每个变量都必须声明其数据类型，数据类型决定了变量占据存储空间的大小

变量的三大用法，赋值，声明，使用

package com.msb.test01;

public class HelloWorld {
    public static void main(String[] args) {
        //[1]变量的声明（定义）
        //定义一个年龄的变量： 年龄，整形变量
        //定义一个变量。名字(标识符)叫age，类型int整形
        int age;
        //变量不可以重复定义
        //同时定义多个变量
        int a,b;
        //[2]变量的赋值
        age  = 18; //等号进行赋值操作
        age  = 32;
        age  = 40+18;
        //变量的定义与赋值可以写在同一行
        int age1 =19;
        int c=18,d=20;
        int e,f=30;//e没有赋值，f赋值为30
        //[3]变量的使用
        System.out.println(age);//使用变量的时候通过名字访问到空间中具体的值
        System.out.println(age + 10);
        int g =20;
        System.out.println(age + g);
    }
}

 数据类型：java的数据类型可以分为两大类

• 基本数据类型        
  • 数值型
    • 整数类型（byte，short，int，long）
    • 浮点类型（float，double）
  • 字符型（char）
  • 布尔型（boolean）
• 引用数据类型
  • 类（class）
  • 接口（interface）
  • 数组

package com.msb.test01;

public class HelloWorld {
    public static void main(String[] args) {
        //基本数据类型
        //【1】整数类型
        byte a =10;//表述范围：-128~127
        short b= 20000;//表述范围：正负三万
        int c=30000000;//表述范围：正负21亿
        long d=10;//表述范围：很大很大，如果表示的数超过int类型的范围就用加L
        //和c语言相同，不同的数据类型的定义所给予的内存是不同的
        //【2】浮点类型
        float e = 3.14f; //如果用float类型表示一个小数，后面必须加上f
        double f = 3.14; //表示精度更高的
        //【3】字符型
        char g =  'a';//单引号引起来叫单个字符
        //""后续学习的字符串是多个单个字符拼接而成的
        //【4】布尔类型
        boolean flag = true; //布尔值只有两个：true、false
    }
}

运算符 运算符的分类与使用

常用  ：算数运算符  ：  +、++

              逻辑运算符：&&、||

package com.msb.test01;

public class HelloWorld {
    public static void main(String[] args) {
       //【1】算数运算符  加号：作用（1）表示正数 （2）表示相加操作（3）字符串拼接
        System.out.println(+10);
        System.out.println(5 + 6);
        int num =10;
        System.out.println("输出一个数：" + num);  //结果为：输出一个数：10
        System.out.println(5 + 6 + "abc");//结果为11abc
        System.out.println("abc"+ 5 + 6);//结果为abc56，只要+两侧任意一侧是字符串，那么结果也是字符串
        //++自增；
        int a = 5;
        a++;//与c语言一样为a+1
        System.out.println(a);//结果是6
        a =5;
        ++a;
        System.out.println(a);//结果也是6
        //无论++放在变量前还是后，都是+1操作
        //如果自增参与到表达式中
        a =5;
        int m = a++ + 7;//如果++在变量后面，先运算，后+1：m=a+7 ，a+1
        System.out.println(a);//6
        System.out.println(m);//12

        a =5;
        int n = ++a + 7;//如果++在变量前面，先+1，后运算：m=a+1 ，a+7
        System.out.println(a);//6
        System.out.println(n);//13


    }
}

赋值运算符 ：= 、+=  

package com.msb.test01;

public class HelloWorld {
    public static void main(String[] args) {
        //赋值运算符
        int num1 =10;
        int num2 =20;
        int num3 =10+30;
        //求和
        int sum = 0;
        sum += num1 ;//等价sum = sum+ num1;
        sum = sum+ num2;
        sum = sum+ num3;
        //sum为0，里面不断加入三个num
        System.out.println("和："+ sum);
    }
}

关系运算符：==

逻辑运算符：&&  ||

package com.msb.test01;

public class HelloWorld {
    public static void main(String[] args) {
        //关系运算符  ==  ,最终的结果是布尔值，要么是true，要么是false
        System.out.println(5 == 6);
        System.out.println(5 == 5);
        //逻辑运算符：左右连接的是布尔值
        //&&逻辑：如果两个操作数都是true，那么结果是true，只要有一个操作数是false，那么结果一定是false
        System.out.println( true && false);
        System.out.println( true && true);
        System.out.println( false && false);
        System.out.println( false && true);
        //||逻辑：如果两个操作数都是false，才是false，只要有一个操作数是true，那么结果就是true
        System.out.println( true || false);
        System.out.println( true || true);
        System.out.println( false || false);
        System.out.println( false || true);
    }
}

流程控制语句是用来控制程序中各语句执行顺序的语句，可以把语句组合成能完成一定功能的小逻辑模块，分为  顺序、选择、循环

• 顺序结构
• 分支结构
  • if分支
    • 单分支
    • 双分支
    • 多分支
  • Switch分支
• 循环结构
  • while循环
  • for循环
  • do-while循环

分支语句：if语句

package com.msb.test01;

public class HelloWorld {
    public static void main(String[] args) {
        //需求：判断一个数是否大于10
        //给定一个数：
        int num =8;
        //判定：if（布尔表达式）
        if (num > 10){//if后面是一个表达式，表达式的结果是布尔值，只有返回结果是true的时候才会走入大括号中
            System.out.println("这个数是大于10的数字");
        }else{
            System.out.println("这个数是小于10的数字");
        }
    }
}

使用单分支搞定：

package com.msb.test01;

public class HelloWorld {
    public static void main(String[] args) {
        //需求：判断学生成绩的等级
        //给定学生的成绩
        int score =98;
        //判定:
        if ( score > 90){//if后面是一个表达式，表达式的结果是布尔值，只有返回结果是true的时候才会走入大括号中
            System.out.println("这个学生成绩的等级是：A级");
        }
        if(score >=80 && score <90 ){
            System.out.println("这个学生的成绩等级是：B级");
        }
        if(score >=70 && score <80 ){
            System.out.println("这个学生的成绩等级是：C级");
        }
    }

使用多分支搞定,代码如下：

package com.msb.test01;

public class HelloWorld {
    public static void main(String[] args) {
        //需求：判断学生成绩的等级
        //给定学生的成绩
        //多分支结构解决问题
        int score =98;
       if(score > 90){
           System.out.println("该学生的成绩等级是：A级");
       }else if(score >= 80){//隐藏条件:score <= 90
           System.out.println("该学生的成绩等级是: B级");
       }else (score >= 70) {//隐藏条件:相当于兜底功能
           System.out.println("该学生的成绩等级是: C级");
       }
    }
}

while循环语句，每个循环都包含四部 条件初始化，条件判断，循环体，迭代

package com.msb.test01;

public class HelloWorld {
    public static void main(String[] args) {
    //功能:求和;
        //定义变量：
        int num = 1;//条件初始化
        //定义一个变量接收和
        int sum = 0;

        while (num <= 5){//如果表达式结果是true，那么就变成死循环了、条件判断
            sum +=num;//循环体
            num++;/迭代
        }

        System.out.println("和："+sum);
    }
}

for循环

package com.msb.test01;

public class HelloWorld {
    public static void main(String[] args) {
        //功能：求和
        int sum = 0;
    for (int num = 1;num <=5;num ++){//条件初始化；条件判断；迭代)
        sum +=num;//循环体
    }

        System.out.println("和："+sum);
    }
}

方法和方法的重载

方法是用来完成特定功能的代码片段         提高程序的复用性

写一次然后使用的时候直接调用即可

先在子文件下创建一个java class称之为method 方法

方法的格式

【修饰符1 修饰符2】  返回值对应的数据类型   方法名（形式参数列表）{

                JAVA语句

}

倘若没有返回值，填入void（空）即可

形式参数的数量需求需要自己去规定

首先定义个方法

package com.msb.test01;

public class testMethod {

        //提取一个方法，功能：将两个整数求和
        public static int addnum(int num1,int num2){//因为返回的和是整形，所以static后是int
            //求和
            int sum = num1 + num2;
            return  sum;   //返回求到的和
        }
        //下面为主程序，调用了上面的方法--addnum
        public static void main(String[] args) {//这个其实就是方法
            //10,20的相加实例
            int a = addnum(10,20);
            System.out.println("结果是：" + a);
        }
    }

方法的重载：在同一个类中，方法名相同，形参列表不同的多个方法，构成了方法的重载，只和方法名和形参列表，要求方法名必须相同，形参列表必须不同（类型、顺序、个数都可以不同）

数组

数组是相同类型数据的有序集合，每一个数据被称为一个元素，每个元素通过索引来访问

特点：

1.长度是确定的，一旦被创建，大小就是不可以改变的

2.其元素必须是相同类型的，不允许出现混合类型

3.数据类型可以是任何数据类型，包括基本类型和引用类型

4.数据有索引的，索引从0开始，到数组长度length-1结束

通过声明、创建、赋值、使用、遍历去认识数组

package com.msb.test01;

import java.awt.image.PixelInterleavedSampleModel;

public class testMethod {
    public static void main(String[] args) {
        //数据声明：以int类型数组为案例；
        int [] arr;//定义一个int类型的数组，名字是arr
        //数组的创建
        arr = new int [4];//在创建的时候要给定数组的长度，创建一个长度为4的int类型的数组
        //int[] arr = new int[4];合成一句话  底层默认长度为4的空间中，每个元素有默认值：0
        //数组的赋值：给数据块赋值相应的数值
        arr[0] =15;
        arr[1] =91;
        arr[2] =47;
        arr[3] =62;
        // arr[4] =10;时报错
        //数组的使用
        System.out.println(arr[3]);
        System.out.println(arr[0]+30);

        //数组的遍历（查看数组中的每一个元素）
        System.out.println("数组的查看：最简单粗暴的查看方式：");
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
        System.out.println(arr[3]);
        System.out.println("数组的查看：for循环的方式");
        for(int i = 0; i <= 3;i++){
            System.out.println("第"+( i +1 )+"个元素为："+arr[i]);
        }
        System.out.println("数组的查看：增强for循环");
        for(int num:arr){//对arr数组进行遍历，遍历出来的每一个元素用num变量接收，注意是：而不是；
            System.out.println( num );//每次循环输出num的值
        }

    }
}

for循环与增强for循环的区别：
for循环 可以涉及与索引相关的操作 增强for循环不可以
但是增强for循环比较简单

面向对象与类

万事万物皆为对象  

类：对对象向上抽取像的部分，公共的部分以此形成类，类就相当于一个模板

对象：模板下具体的产物可以理解为具体对象，对象就是一个一个具体的实例，就相当于这个模板下具体的产品

java中先定义类，再定义对象

类的编写  需要重新到ssc目录下创建类   名称为person

首先在文件夹中创造一个java class，对类进行编写：

package com.msb.test02;

public class person {
    //对特性-属性进行编写（只定义和业务逻辑相关的代码）
    String name;   //姓名
    int age;//年龄
    double height;  //身高

    //对行为-方法进行编写
    //定义一个学习的方法：
    public void study(){
        System.out.println("青，取之于蓝而青于蓝；冰，水为之而寒于水");
    }
    //显示编写空构造器
    public  person(){
        System.out.println("调用了空构造器");
        /*
        倘若在这儿放入
        age =19;
        name="陈小萱";
        height =171.0;
        则会导致p1与p2 数据相同，缺失个性化数据
         */
    }

    public  person (int a ,String b ,double c) {
        this.age = a;
        this.name =b;
        this.height =c;
        //如果构造器参数名字和属性名字重名(age =age)，就会发生就近原则
        //如果重名，你想给属性赋值，就要在表达属性的变量前加上this.来修饰
    }
}

然后先相同文件夹中再创造一个对象的使用：

package com.msb.test02;

public class test {
    //程序的入口
    public static void main(String[] args) {
        //对person类的对象进行创建
        person p1 = new person();//创建了person对象，名字叫P1
        //对属性进行赋值：
        p1.name="张旭升";
        p1.age =23;
        p1.height = 183.5;
        //对属性进行读取
        System.out.println(p1.age);
        System.out.println(p1.name);
        //调用对象的方法
        p1.study();
    }
}

对于类来说，一般有三个常见的成员：属性、方法、构造器

这三个成员都可以定义零个或多个

构造方法也叫构造器，是一个创建对象被自动调用的特殊方法，用于对象的  初始化，

package com.msb.test02;

public class test2 {
    public static void main(String[] args) {
    /*
    创建一个person的对象
    new person()
    person()->空的构造方法
    new 关键字对方法进行调用-- >构造器作用：底层帮我们创建对象，在创建对象后进行初始化操作
    如果一个类没有显示编写构造器的话，那么系统会为这个类默认分配一个空构造器
    调用构造器之后，对对象进行初始化操作，将对象的地址返回给p


     */

        person p = new person(18,"陈小萱",170.1);
        /*
        p.age =18;
        p.name ="陈小萱";
        p.height = 171.0;
              */
        System.out.println(p.age);
        person p2 = new person(20,"陈小娟",172.0);
        /*p2.age =20;
        p2.name ="陈小娟";
        p2.height= 171.2;    这种形式具备了个性化，但是比较麻烦
        */
        System.out.println(p2.age);
        //如果一个类中有构造器，那么系统就不会帮你分配默认的空构造器
        person p3 = new person();
        //构造器的快速添加快捷键alt+insert->构造器->选择属性
    }

}

注：在java class ---person中，已经添加了调用的空构造器，所以才可以在这儿调用

封装

也就是程序员设置权限，自己的权限以及他人的权限，自己只暴露少接口，然后供外部进行调试用

先创建girl 

package com.msb.test01;

public class girl {
    //属性：
    private int age;//private隐藏起来，也就是设置权限，在其加入限制条件
    //给age提供一个赋值的方法：
    public  void shezhiage(int age){
        if(age>30){
            this.age =18;
        }else{
            this.age =age;
        }
    }
    //给age提供一个读取值的方法：
    public  int duquage(){
        return  age;
    }
    //快捷添加封装的方法alt+insert-->getter & setter
    
}

再创建一个test

package com.msb.test01;

public class test {
    public static void main(String[] args) {
        //创建一个对象：
        girl g =new girl();
        g.shezhiage(29);
        System.out.println(g.duquage());
    }//内部操作数据自己完成，不允许外部干涉
    //隐藏对象内部的复杂性，只对外公开简单的接口方便调用，提高可扩展性与可维护性，提高安全性
    //这就是封装
}

继承（对类的抽象）

人类（父类）

学生  教师  员工（子类）

子类 extends 父类

提高了代码的复用性与扩展  

是多态使用的前提

先建立父类，也就是共同拥有的特征的点

package com.msb.test01;

public class person {
    //父类中公共的属性并加接口
    private  int age;
    private  String name;
    private double height;

    //父类公共的方法：
    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }

    //吃饭
    public  void eat(){
        System.out.println("人类可以吃饭");
    }
    //睡觉
    public  void sleep(){
        System.out.println("人类可以睡觉");
    }
    //喊叫
    public  void shout(){
        System.out.println("人类可以喊叫");
    }
}

再建立子类

package com.msb.test01;

public class student extends  person {//子类student extends 父类person
    //定义子类额外的、扩展的属性
    private  int sno;
    //定义子类额外的、扩展的方法

    public int getSno() {
        return sno;
    }

    public void setSno(int sno) {
        this.sno = sno;
    }
    //学习：
    public void study(){
        System.out.println("学生可以学习");
    }
}

 进行测试

package com.msb.test01;

public class test {
    public static void main(String[] args) {
        //定义一个子类具体的对象
        student s =new student();
        s.setSno(100100);
        s.setAge(18);
        s.setName("陈小萱");
        s.setHeight(171.2);

        s.study();
        s.eat();
        s.sleep();
        s.shout();
    }
}

 方法的重写

 重写建立在继承条件下，当子类对父类提供的方法不满意的时候，要对父类的方法进行重写

并且有着严格的要求，方法名称与父类必须一致，参数列表（个数、顺序、类型）也要与父类一致

重载与重写的区别：

重载：在同一个类中，当方法名相同，形参列表不同的时候，多个方法构成了重载

重写：在不同的类中，子类对父类提供的方法不满意，对父类的方法进行重写

多态

 通俗来说，多态就是多种形态，具体就是完成某个行为，当不同的对象去完成时产生不同的状态，同一种行为，不同的子类呈现出来的状态是不同的，

多态与属性无关，多态指的是方法的多态，而不是属性的多态

ps：未完待续

Java代码问题报错以及解决方法总结：

---

问题1：java: 需要 class、interface、enum 或 record

解决方法：有括号打多了，检查一下

问题2：错误: 找不到或无法加载主类 com.msb.test01.HelloWorld

解决方法：重新创建文件进行打印即可

问题3：类 testMethod 是公共的, 应在名为 testMethod.java 的文件中声明

解决方法：应该讲外部的文件名称改成与方法名称文件一致便可以解决