Java基础知识梳理---从配置环境变量到完成学生管理系统

  时间:2022-05-11 13:35:35  阅读量:18  评论数:0  作者:

该篇文章Java基础知识梳理---从配置环境变量到完成学生管理系统除了讲述概念知识,更举例源码分析教学,对这方面技术有需求的朋友可以参考着学习,实用性较强。

在这里插入图片描述个人介绍


大家好我是:一颗松
认真分享技术,记录学习点滴
如果分享对你有用请支持我哦🍺

点赞:👍 留言:✍收藏:⭐️

个人格言: 想法落实的最佳时机就是现在!🏄


初学须知
:::info
💡 1. 常用百度
💡 2. 一定要动手敲,并长时间坚持(第一遍可能会很难)
💡 3. 多思考并自行实现功能代码
:::

1 java基础知识梳理

用思维导图,结构化展现java基础大概内容。

2 开发环境搭建

学习编程,必须有自己的开发环境

2.1 安装JDK

  1. 拓展知识:
  • java语言是跨平台语言,一套java代码可以去多个系统软件上运行(Windows、macOS、Linux…),但前提是需要在系统软件上安装有java运行环境(JRE);
    1. JRE:(java Runtime Environment)java运行环境,它**包含java虚拟机(JVM)**和一些标准类库;
    2. JVM:(Java Virtual Machine),java字节码文件(.class)在虚拟机上运行。java程序离不开java虚拟机。
    3. JDK: Java Development Kit,java语言开发工具包,包含java运行环境JRE和java工具
  • JDK、JRE、JVM三者之间是包含与被包含关系

  1. 安装JDK
    1. 打开浏览器输入甲骨文公司官网(https://www.oracle.com),在导航栏点击产品(Products)进入页面底部,选择java

在这里插入图片描述

  1. 进入java页面,翻到页面底部选择Orele JDK

在这里插入图片描述

  1. 进入下载页面根据需求下载
    在这里插入图片描述

  2. 安装过程一路next就可以(如果想修改安装目录,最好安装在纯英文目录下)

2.2 配置环境变量

  1. 为什么要配置环境变量?

答:因为在不配置环境变量的情况下,java的编译运行操作只能在java安装目录下进行,使得工作很难展开。(高版本JDK会自动配置环境变量,存在功能不全问题;建议手动配置)

  1. 配置工作
    1. 找到此电脑,右击选择属性

在这里插入图片描述

  1. 进入属性界面后选择高级系统设置

在这里插入图片描述

  1. 进入系统设置后选择高级,再选择环境变量设置

在这里插入图片描述

  1. 进入环境变量配置页面后在系统环境变量下,选择新建

在这里插入图片描述

  1. 新建JAVA_HOME并配置安装目录到jdk版本目录

在这里插入图片描述

  1. 在path环境变量下,添加新配置;配置内容:“%JAVA_HOME%\bin”

在这里插入图片描述

在这里插入图片描述

到这里配置就算完成了。

  1. 怎么检查是否配置成功?

答:在键盘上,按住win键+R键 ,输入“cmd”;
然后在DOS窗口输入“java -version”如果有出现java版本信息,那么恭喜你成功啦
在这里插入图片描述


3 java基础语法

清楚基础语法知识对于后期学习是十分必要的,一点一点的必须搞懂;
注意:【java语言中对字母的大小写是严格区分的,大写和小写代表两个东西。】
我们先看一个完整java程序案例:

案例1 — HelloWord案例

public class HelloWord {
    public static void main(String[] args) {
        System.out.println("HelloWrod");
    }
}

3.1 标识符和关键字

  1. 什么是标识符?

标识符:java开发中用到的名字,就是各种名字:变量名、类名、包名等等;
案例1中:HelloWord是类名、main是方法名,args是变量名;这些都是标识符

名字呢不能乱起,那么该如何命名?【标识符的命名规则】

  • 只能由:数字、字母、下划线(_)和“$”组成!不能出现其他任何字符。
  • 不能以数字开头

江湖规则1: 小驼峰命名法,一个单词时全小写,多个单词时从第二个单词开始首字母大写,常见在(变量、方法名)
江湖规则2: 大驼峰命名法,每个单词首字母大写常见在(类名)话说不遵守江湖规则是行不通滴;

注意:【标识符要做到见名知意】

  1. 关键字是什么?

关键字:java中有特殊含义的单词,在高级记事本或者集成开发环境中都会用不同的颜色显示;不需要特意背知道常见,慢慢积累;

java常用关键字:

classpublicstaticprivate
breakcontinuedefaultimport
ifelseforwhile
intshortchardouble
floatswitchlongreturn

3.2 常量和变量

常量和变量都描述的是数据,数据有不同的类型我们首先了解一下java中的数据类型

  1. 常量:就是值不会发生改变的数据,比如:2,‘a’,"java"等等

此处需要注意的是:

  • 浮点型常量:浮点型就是小数类型常量,小数默认是double类型,如果是float类型数值后必须加F或f
  • 字符型常量:用单引号括起来的的单个字符如:‘a’、‘6’、'A’等等;
  • 字符串常量:用双引号括起来的内容如:“helloword”、“15121”、" "等等;

注意:空字符串"",字符串的值为空;空字符’'会报错

  1. 变量:变量定义格式
  1. 数据类型 变量名;
  2. 数据类型 变量名 = 变量值;

3.3 运算符

  1. 算术运算符:
符合含义
+、-、*、/与数学中使用方法一样
%取模(也叫取余)
++、- -自增、自减运算符

算术运算符注意事项【面试题】:

  • 以下语句会不会报错?为什么?
		short num1 = 10,num2;
        byte num3 = 20;
        num2 = num1+num3;      //第一句
        //---------------------------------------------------
        num2 = 200+30;			//第二句
        //-------------------------------------------------
        num3 = 120+10;		  	//第三句
        //-------------------------------------------------
        //解析
        /*
			第一句:会报错,这边存在一个隐式转换;【任何整型变量在计算时都会默认转为int类型】再做计算;此处num1与num3会先转int计算完再赋值,然而num2是short类型,大类型值赋值给小类型会报错;
			第二句:不会报错,此处存在常量优化机制,因为200与30都是常量,在编译过程中会将结果计算出来,再给num2赋值;num2是short类型230在它的范围内;所以不会出错;
			第三句:会报错,虽然java有常量优化机制,但是,此处优化后的结果是130,超出了byte的范围;【byte范围:-128----+127】
		*/
         
  1. 赋值运算符:
符号含义
=赋值运算符,将符号右边的值赋给左边变量
+=加等
-=减等
/=除等
%=取模等

赋值运算案例:

		int  num2  = 20;		//把 常量20赋给num2
		//-----------------------------------------------
		byte num3 = 20;
        num3 += 20;	//此处实质是:num3 = (num3类型)(num3+20)

注意: 【类似+=、-=、%=这样的赋值运算存在默认强制转换机制】

  1. 判断运算符:
符号含义
==、!=、等于、不等于
“>”、<、>=、<=大于、小于、大于等于、小于等于
  1. 逻辑运算符:
符号含义
&、!、与、非
&&短路与
|        // 逻辑或
^        // 逻辑异或
||		 // 短路或

两个变量值互换要求:不用第三方变量【面试题】:

  • 方案1 数学思维解决
 		int num1 = 20;
        int num2 = 30;
        num1 = num1+num2;
        num2 = num1-num2;
        num1 = num1-num2;
  • 方案2 用异或解决【一个数被另一个数连续异或两次,这个数值不变】
	    int num1 = 20;
        int num2 = 30;
        num1 = num1^num2;
        num2 = num1^num2;
        num1 = num2^num1;

4 数组

4.1 一维数组

1. 数组概念:
数组是一个可以存储多个相同数据类型的数据的容器;

2. 数组的定义与初始化

数据类型 [ ] 数组名;
数据类型 数组名 [ ];

3. 静态初始化,两种格式:

完整格式1
数据类型 [ ] 数组名 = new 数据类型[ ] { 数据1,数据2,数据3… };
简化格式2
数据类型 [ ] 数组名 = { 数据1,数据2,数据3… };

静态初始化 案例-1

        //数组定义初始化完整格式
        int [] arr1 = new int[]{1,2,3};
        //数组定义初始化简化格式
        int [] arr2 = {1,2,3};

4. 动态初始化格式

数据类型 [ ] 数组名;
数组名 = new 数据类型 [ 所需的存储空间];

动态初始化 案例-2

  int [] arr3;//定义数组
  arr3 = new int[10];//动态初始化
  arr3[0] = 15;
  arr3[1] = 20;
  .
  .
  .
  arr[9] = 9

5. 数组元素访问

  • 索引
    索引的概念:容器中空间的编号就是索引,索引值从0开始(容器中空间编号从0开始)
  • 元素:数组中存储的数据被称为

访问格式

格式:数组名 [索引值];
eg: int [] arr2 = {1,2,3};
arr2[0];
arr2[1];
注意:数组元素以索引值访问时只能,一个一个单独访问,不能同时出现多个索引值;

错误示例: arr2[0,1,2];

访问案例

 int [] arr2 = {1,2,3};
 System.out.println("arr2数组中第一元素为:"+arr2[0]);

6. 数组遍历
数组遍历:就是把数组中的每个元素,依次都访问一遍;

数组遍历,输出所有元素格式:

for (int i = 0; i < 数组长度; i++) {
System.out.println(“数组值:”+数组名[i]);
}

友情提示:【IDEA快捷键—生成遍历框架【 数组名 .fori +Enter 】

案例2—数组案例集

数组遍历输出 案例-3

int [] arr2 = {1,2,3};//定义,静态初始化数组
for (int i = 0; i < arr2.length; i++) {
    System.out.println("数组值:"+arr2[i]); //遍历输出arr2数组中的每个元素
}

求数组元素偶数和 案例-4

 int [] arr4 = {1,2,3,4};		 //静态初始化数组
        int sum =0;
        for (int i = 0; i < arr4.length; i++) {
            if (arr4[i]%2==0){	//通过取模筛选出所有偶数
                sum += arr4[i];	//累加计算偶数和
            }
        }
        System.out.println("数组元素中所有偶数和为:"+sum);	//输出偶数和

求数组元素中最大值 案例-5

 public static void main(String[] args) {
        int [] arr5 = {1,15,20,9,88,8}; //静态初始化数组
        for (int i = 1; i < arr5.length; i++) {
            if (arr5[0]<arr5[i]){ //筛选出大于arr5[0]的数
                arr5[0] = arr5[i];//将筛选出的数,赋值给arr5[0]
            }
        }
        int max = arr5[0];			//将arr5[0]赋值给max变量
        System.out.println("次数组最大值为:"+max);
    }

4.2 数组初始化内存分配图解

 public static void main(String[] args) {
        int [] arr = new int [7]; //动态初始化一个长度为10的数组
    }

方法区: java中字节码文件会存在方法区;【注意:字节码文件不调用不加载】
栈内存: java把内存分为两部分,栈内存和堆内存,基本类型变量存于栈内存,栈内存存储特点,先进栈的内容后出栈;
堆内存: 所有new出来的东西存放在堆内存中。
在这里插入图片描述
当arr的值为null时,再访问arr数组元素时,就会出现空指针异常,报错如下:

Exception in thread "main" java.lang.NullPointerException
	at HelloWord.main(HelloWord.java:8)

4.3 二维数组

二维数组就是,一维数组的元素时一维数组;也就是数组存数组,这边不详细展开


5 流程控制

流程控制在各编程语言中通用,所以这是必须要掌握的第4点内容

5.1 顺序结构

程序默认是按照从上往下的顺序,执行流程;

5.2 分支结构

5.2.1 if语句(判断条件最终必须为:布尔类型值)

  1. 简单if语句格式:

语句格式:
if (判断条件){
语句体; //判断条件成立执行语句体;
}

int nub1 = 1;
int nub2 = 2;
if(nub1>nub2){
       System.out.println("执行了语句体");  //判断条件为false,此语句不执行;
}
  1. if…else语句格式

语句格式:
if (判断条件){
语句体1; //判断条件成立执行语句体1;
}else{
语句体2; //判断条件不成立执行语句体2;
}

int nub1 = 1;
int nub2 = 2;
if(nub1>nub2){
       System.out.println("执行了语句体1");  //判断条件为false,此语句不执行体;
}else{
       System.out.println("执行了语句体2");  //判断条件为false,执行此语句体;
}
  1. if…else if…else…语句格式

语句格式:
if (判断条件1){
语句体1; //判断条件成立执行语句体1;
}else if(判断条件2){
语句体2; //判断条件1不成立,判断条件2成立,执行语句体2;
}else{
语句体3; //判断条件1和2都不成立执行语句体3;
}

案例3—成绩奖励(if案例)

/*
考试奖励:
    分数>=90:奖励自行车一辆
    90>分数>=80:奖励游乐园一日游
    80>分数:一顿狂揍
*/
public class IfTest {
    public static void main(String[] args) {
        int chengji;
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入成绩:");
           chengji = sc.nextInt();
           if (chengji <=100 && chengji>=0){
               if (chengji>=90){
                   System.out.println("恭喜!奖励自行车一辆!");
               }else if (chengji>=80 && chengji<90){
                   System.out.println("恭喜!奖励游乐园一日游!");
               }else{
                   System.out.println("来吧一顿接受狂揍!");
               }
           }else{
               System.out.println("成绩输入有误!");
           }
    }
}

5.2.2 switch语句
switch语句格式:如下伪代码所示

 switch(variable){
           case 1:
               语句体1;
               break;
           case 2:
              语句体2;
               break;
           case 3:
               语句体3;
               break;
               .
               .
               .
           default:
               默认语句;
               break;
       }
  1. variable的取值范围
  • 基本类型:byte、short、int、long
  • 引用类型:jdk5开始,允许枚举类型;jdk7开始,允许String
  • jdk14开始允许,一个case 后跟多个值:case 1,2,3:
  • if与switch选用:范围性的判断用if更合理;switch更适合固定值判断;
  1. case穿透(可以优化代码)

case穿透示例:如果有多个重复的语句体可以使用case穿透

switch(variable){
    case 1:
    case 2:
    case 3:
        //重复语句体;
        break;
    default:
        break;
}
  1. jdk14以后新特性(可以优化代码)

case穿透示例:如果有多个重复的语句体可以使用case穿透

switch(variable){
    case 1,2,3:
        //重复语句体;
        break;
    default:
        break;
}

案例4 — 成绩录入输出评价(switch案例)

等级评语
A成绩良好
B成绩中等
C及格
D成绩不合格
System.out.println("请输入成绩:可选项【A、B、C、D】");
        switch ('B') {
            case 'A':
                System.out.println("成绩良好");
                break;
            case 'B':
                System.out.println("成绩中等");
                break;
            case 'C':
                System.out.println("及格");
                break;
            default:
                System.out.println("成绩不合格!");
                break;
        }

switch语句执行流程:
第一步:拿variable值与case值对比,如果对比结果相等,则进入语句体,直到遇到break;或者执行结束才会退出switch语句;
第二步:如果在case中没有匹配到值,就会进入default语句,直到遇到break;或者执行结束才会退出switch语句。在switch语句中 执行顺序与case 、default的位置无关;

知识拓展【三目运算符:】

三目运算符格式:
判断条件 ? 值1 : 值2;

执行流程:
1 判断条件是否为真?
2 如果判断条件为真,则 值1 赋给这这条语句的结果;
3 如果判断条件为假,则 值2 赋给这这条语句的结果;

案例5—三目运算符操作案例:

public void  operator(){
    int a,b,c;
    a = 10;
    b = 20;
    //第一种情况判断条件(b>a)为真
    c = b>a ? a:b;//c的值为10;
    //第二种情况判断条件(b<a)为假
    c = b<a ? a:b;//c的值为20;
}

5.3 循环结构

使用循环的条件:

某个操作需要重复执行多次


5.3.1 for循环

  1. for循环的使用
//for循环格式:

    for(初始化语句;条件判断语句;条件控制语句){
       //循环体语句;
    }
//在for循环中,初始化语句只执行1次;
//for循环案例:
 public static void main(String[] args) {
        for(int i =0;i<3;i++){
            System.out.println("执行第"+i+"次循环!");
        }
    }
  1. for循环执行流程(重中之重)
 for(初始化语句;条件判断语句;条件控制语句){
       //循环体语句;
    }


注意:【在for循环中初始化语句只执行一次】

案例6 — 求100以内偶数和(for循环案例)

//for循环案例3(1-100之间的偶数和)
//实现方案1
        int sum =0;
        for (int i = 1;i<=100;i++){
            if (i%2==0){
                sum += i;
            }
        }
        System.out.println("1-100之间偶数和为:"+sum);
//实现方案2
        int sum =0;
        for (int i = 2;i<=100;i+=2){
                sum += i;
        }
        System.out.println("1-100之间偶数和为:"+sum);

案例7 — 打印所有水仙花数(for循环)

需求分析:什么是水仙花数?
答:水仙花数是一个三位数,它的每个位上的数字的 3次幂之和等于它本身。
步骤分析:

1 通过for循环筛选出三位数
2 通过if按照水仙花数概念,晒出水仙花数

  //for循环找出水仙花数
        for (int i=100;i<=999;i++){
            int ge,shi,bai; //定义各位、十位、百位变量准备后续操作
            ge = i%10;
            shi = i/10%10;
            bai = i/100;
            //用if对水仙花数条件进行筛选
            if (i==(ge*ge*ge+shi*shi*shi+bai*bai*bai)){
                System.out.println("水仙花数:"+i);
            }
        }

6 java中的方法

6.1方法的概念与功能

方法概念:具有独立功能的代码块【在其他语言中也叫函数】
方法作用:
a. 按功能将代码分类,提高代码可读性
b. 方便后期代码维护
c. 提高代码复用性

IDEA涨知识:Ctrl + F12,打开类的大纲

6.2 方法定义格式:

6.2.1 方法定义格式:
无参方法定义格式:

修饰符 返回值类型 方法名(){
return 返回值;
}

带参方法定义格式:

修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2){
return 返回值;
}

6.2.3 形参(形式参数)与实参(实际参数)

形参:定义方法时声明的参数
实参:调用时传入的实际参数

//形参
public static void prints(int num) { //此处的 num就是形参
     //方法体语句
 }
//main方法调用prints()方法时需要传实参
 public static void main(String[] args) {
          prints(5);				//此处5就是实际参数
 }

案例8— 方法定义


//1无参方法
    public static void prints() {
        System.out.println("*******************");
    }

//2带参方法
    //案例1 主方法:
        public static void main(String[] args) {
                //方法体语句
        }
    //案例2 自定义方法:
         public static int sum(int num1,int num2){
                int sum = num1+num2;
                return sum;//返回值
         }

6.3 自定义方法的位置:

方法与方法之间保持平级关系,方法不允许嵌套定义;

6.4 方法的调用与执行:

方法不调用不执行:
方法的执行顺序与编写顺序无关,只与调用顺序相关;

方法的调用方式1: 用类名直接调用,被static修饰的方法,属于类所有,可以直接用:类名.方法名(); 直接调

方法的调用方式2: 通通对象调用,对象名.方法名();

6.5 方法调用内存图解

6.6 java方法的值传递与址传递

问题:在java中方法传参到底是值传递还是址传递?
答:java参数传递问题需要分情况讨论:

  • 传递的参数为基本类型,则是值传递;
  • 传参为引用类型参数,就是址传递;
  1. 基本数据类型

案例1:【问:num1的值会不会变? 答:不会】

  public static void main(String[] args) {
        int num1 = 100; //定义变量num1
        test1(num1);    //把num1,作为参数传给test1方法
        System.out.println(num1);
    }
    public static int test1(int num1){
        return num1 = 200; //在test1方法中,给num1重新赋值
    }

基本数据类型作为参数的内存图解:


2. 引用类型数据

案例1:【问:num1的值会不会变? 答:会】

  public static void main(String[] args) {
        int [] num1 = {10,11}; //定义数组num1
        test1(num1);    //把num1地址,作为参数传给test1方法
        System.out.println(num1[0]);
    }
    public static int test1(int [] num1){
        return num1[0] = 200; //在test1方法中,给num1[0]重新赋值
    }

引用类型数据作为参数的内存图解:

案例9— 定义方法做输出

 public static void prints(int freq) {
        if(freq<0 ){
            System.out.println("输入次数有误,请重新输入:");
        }else {
            for (int i = 0; i < freq; i++) {
                System.out.println("学好编程!");
            }
        }
    }

7 初识面向对象

面向对象是java语言的一大特征,也是java学习分水岭,理解掌握好这块基础对后期学习而言非常必要

7.1 类与对象

7.1.1. 类是什么?
答:类是把一类事物的属性,行为抽象成一个java文件,用文件来表现这类事物,那么这个文件就是一个类;
7.1.2. 对象是什么?
答:对象是类的一个具象,比如:通过一个描述所有人特征的类,可以具象出某一个具体的人如张三;通过人类产生的这个张三,就是人类的一个对象;
7.1.3. 类的特征
a. 类包含成员变量和成员方法
定义在类中的变量:叫成员变量
定义在方法中的变量:叫局部变量

成员变量成员变量是对同一类事物共同属性的一个抽象
成员方法成员方法是对同一类事物共同行为的一个抽象

7.1.4. 类的定义
定义格式:

修饰符 class 类名{
成员变量;
成员方法;
}

案例9 ----定义学生类

public class Students {
   int age;         //学生类成员变量age
   String name;     //学生类成员变量name
   void speak(){    //学生类成员方法speak
       System.out.println("大家好!我是"+name+"今年"+age+"岁");
   }
}

【注意:】类定义时,class前的public有什么用?
答:public修饰的类有最大权限,大家都可以访问,程序的主类必须用public修饰;被public修饰的类,类名与文件名必须保持一致,否则报错;

7.1.5. 对象的创建和使用
对象的创建格式:

类名 对象名 = new 类名();

案例10—根据案例9创建学生对象张三

public static void main(String[] args) {
        Students zhangsan = new Students();		//创建学生对象张三
        zhangsan.age = 18;									//用对象为成员方法赋值
        zhangsan.name = "张三";							
        zhangsan.speak();										//用对象调用成员方法
    }

7.2 构造方法

构造方法又叫构造器

是在构建、创造对象的时候调用的方法,(没有构造方法不能创建对象)
注意:【一个类中如果没有手动写构造方法,系统会默认提供一个无参构造方法】

7.2.1. 构造方法格式

  • 构造方法名 与类名相同
  • 没有返回值类型,连void也没有
  • 没有具体返回值,不能使用return带回结果

注意:【在构造方法中“return;”是可以存在的,this代表当前类对象的地址,谁调用代表谁】

案例1-构造方法格式

class Students{	  //创建Students类
    String name;  //成员变量name
    int age;      //成员变量age
    //无参构造方法
    Students(){}
    //带参构造方法
    Students(int age,String name){ 
        this.age = age;   //通过局部变量为成员变量age赋值
        this.name = name; //通过局部变量为成员变量name赋值
    }
}

7.2.2. 构造方法的作用

2.1 本质作用是用于创建对象
2.2 可以在创建对象的时候,直接给成员变量赋值

案例2–通过构造方法为成员变量赋值

public class ThisDemo {
    public static void main(String[] args) {
        Students stu1 = new Students(18,"小明"); //创建对象stu1,并传参
    }
}
class Students{
    String name;  //成员变量
    int age;      //成员变量
    Students(int age,String name){ //构造方法
        this.age = age;   //通过局部变量为成员变量age赋值
        this.name = name; //通过局部变量为成员变量name赋值
    }
}

7.2.3. 构造方法内存解析(案例2解析)

注意:【字节码文件不调用不加载】

7.3 java面向对象的特征

话说java万物皆对象,怎么理解呢?
答:生活中的所有事务我们都可以进行归类,归类后就能找出共性,共同属性,共同行为等等那么就可以将事物抽象成类;一个类可以创建无数对象,这样就便于开,发节省开发成本。也就是万物皆对象。
7.3.1 java的封装
什么是封装?

答:大概可以这么理解,就好比公开且无人管的器材室,所有人都可以随意出入,里面篮球🏀、足球⚽、羽毛球🏸等等器材大家都可以自由使用想怎么用就怎么用。封装就是现在来了一个管理员器材室不能随意出入了,你要东西可以,但是不能让你自己随意拿了,得经过管理员之手。(这段纯属我自己理解的,有问题欢迎在评论区指正)

a. 此处公开就对应权限修饰:public,被public修饰的属性用最大权限,可以被任意class调用;
b. 不公开就对应:private,被private修饰的属性只能在本类内部使用,外部无法直接访问,但是可以通过类提供的public修饰的方法间接访问。

为什么要封装?封装有什么好处?

  1. 外部不能直接访问、提高代码的安全性,可控性更方便管理;
  2. 降低程序复杂度。

案例11—学生类的封装案例


public class Studens {
    private int age;        //定义成员变量 age并私有
    private String naem;    //定义成员变量 name并私有

    public Studens() {      //无参构造
    }

    public Studens(int age, String naem) {  //带参构造
        this.age = age;
        this.naem = naem;
    }

    public void speak(){
        System.out.println("讲中国话");     // 成员方法
    }

    public int getAge() {                  //为外部提供变量访问的方法getXxx方法
        return age;
    }

    public void setAge(int age) {           //为外部提供变量访问的方法setXxx方法
        this.age = age;
    }

    public String getNaem() {               //为外部提供变量访问的方法getXxx方法
        return naem;
    }

    public void setNaem(String naem) {      //为外部提供变量访问的方法setXxx方法
        this.naem = naem;
    }
}

继承、多态java进阶补充;
7.3.2 java的继承

7.3.3 java的多态


8 初识javaAPI

javaAPI(Application Programming Interface)应用程序编程接口

8.1JavaAPI帮助文档的使用方法

什么是API?
答:API本质就是java为开发者提供的工具类,这些类功能强大,为开发工作提供得力助手。
如何学习API?
答:需要阅读官方提供的API开发文档;
阅读步骤:

  1. 打开开发文档,在导航栏选择索引选项,输入自己想要查询的类名:

在这里插入图片描述

  1. 查看类是不是在java.lang包下,如果是则使用是不需要导包,不是则要导包;

在这里插入图片描述

  1. 接着看类的介绍,可以做什么;
  2. 看构造方法,因为构造方法是我们创建对象时候必须用的,根据构造方法创建对象;
  3. 看成员方法;

8.2 String类的介绍

  • 在java中所有被“”包裹的内容都是String类的对象;

  • 字符串一旦被创建,则值就不会发生改变;

  • 字符串常量池:
    JDK8之前常量池在方法区
    JDK8以后被迁移到堆内存

案例12----字符串常量池面试题

回答问题并说明原因:

 public static void main(String[] args) {
        boolean flag;
        //第一题
        String str1 = "hello";
        String str2 = new String("hello");

        flag = str1 == str2 ;
        System.out.println("第一题,输出为true还是false?:"+flag);

        //第二题
        String str3 = "hello";
        flag = str1 == str3;
        System.out.println("第二题,输出为true还是false?:"+flag);
    }

解析:①此处涉及到字符串常量池知识,在用“”直接创建字符串对象时,首先会到字符串常量池中查找是否有该字符串,如果有直接从常量池中把地址拿给字符串常量,如果没有则往常量池中添加新元素。
②用new方法创建字符串对象时,在栈内存开辟变量空间后,再到堆内存new出一块新空间,此时拿参数字符串对象去常量池中复制一份赋值给new出来的空间,再将空间地址赋给字符串变量;

  • String类的常见方法
方法功能
boolean equals(Object anObject)比较两个字符串是否相等
boolean equalsIgnoreCase(String anotherString)比较两个字符串是否相等(忽略大小写)
char [] toCharArray()将字符串转换为一个新的字符数组

案例13—自定义方法统计指定字符在本字符串中出现的次数

public static int countChar(String String, char cha) {
        int count = 0;                          
        char []arr = String.toCharArray();      //使用String类的toCharArray方法将字符串转为字符数组
        for (int i = 0; i < arr.length; i++) {  //for循环遍历数组
            if (cha == arr[i]){                 //if语句对比字符,用count统计
                count ++;
            }
        }
        return count;                           //返回统计数
    }

8.3 Random类

方法含义
int nextInt(int n)返回一个伪随机数,它是取自此随机数生成器序列的、在 0(包括)和指定值(不包括)之间均匀分布的 int 值。

规则简单记:【包左不包右】

案例14—java小游戏【猜数字】

public static void numGame() {
        int count = 3;                                    //控制循环次数
        Random r = new Random();
        int num = r.nextInt(100)+91;               //生成0---100的随机数
                Scanner sc = new Scanner(System.in);
        while (count > 0){                               //循环控制输入次数
            System.out.println("请输入1--100的随机数值:");
            int numb = sc.nextInt();
            if (num==numb) {
                System.out.println("恭喜您猜对啦!");
                break;
            }else if (numb<num){
                System.out.println("您猜的数偏小,您还有"+(count-1)+"次机会!");
                count --;
            }else {
                System.out.println("您猜的数偏大,您还有"+(count-1)+"次机会!");
                count --;
            }
        }
    }

9 初识集合

9.1 ArryList集合

  • ArrayList构造方1
    • public ArrayList();
  • 泛型:<>
    • 在类名之后加<>,可以使集合存储的数据类型,进行类型限制;
    • 尖括号中只能使用引用数据类型,不能是基本数据类型

解决方案:【基本类型都有对应包装类】

基本数据类型对应包装类
intInteger
shortShort
byteByte
doubleDouble
floatFloat
charCharacter

1 ArrayList的常用成员方法

    • public boolean add(E e);向集合尾部添加数据,返回添加成功的状态
    • public void add(int index,E element);插队添加
 ArrayList<String> list1 = new ArrayList<>();//创建list集合
        list1.add("张三");                    //添加元素

    • public E remove(int index);根据索引删除集合中的元素
    • public boolean remove(元素);根据元素删除集合中的内容,重复元素只删除第一个;返回添加成功的状态
 ArrayList<String> list1 = new ArrayList<>();//创建list集合
        list1.add("张三");                    //添加元素
        list1.add("王五");
        list1.add("上官铁蛋");
        list1.add("张三");
        list1.add("诸葛订单");
        list1.remove("张三");                //根据元素删除
        list1.remove(2);                    //根据索引值删除元素

    • public E set(int index,E element);修改指定索引位置,返回被覆盖的元素
ArrayList<String> list1 = new ArrayList<>();//创建list集合
        list1.add("张三");                   //添加元素
        list1.add("王五");
        list1.add("上官铁蛋");
        list1.add("张三");
        list1.add("诸葛订单");  
        list1.set(2,"年薪百万");             //修改集合数据

    • public E get(int index);根据索引,获取集合中的元素
      ArrayList<String> list1 = new ArrayList<>();//创建集合
        list1.add("张三");                        //添加元素
        list1.add("王五");
        list1.add("上官铁蛋");
        list1.add("张三");
        list1.add("诸葛订单");
        list1.get(2);                           //查找集合元素

案例15 ----ArrayList初使用

创建一个存储字符串集合,存储5个字符串元素,找出4个字的人名,并打印

 public static void main(String[] args) {
        ArrayList<String> list1 = new ArrayList<>();//创建list集合
        list1.add("张三");                           //添加元素
        list1.add("王五");
        list1.add("上官铁蛋");
        list1.add("张三");
        list1.add("诸葛订单");
        for (int i = 0; i < list1.size(); i++) {    //遍历集合
            String name = list1.get(i);             //获取集合元素
            if (list1.get(i).length()==4){          //判断字符串长度是否为4
                System.out.println(name);           //打印4个字的名字
            }
        }
    }

学生管理系统实现

关键词:java,基础,基础知识,知识,梳理,配置,环境,环境变量,变量,完成,学生,学生管理,学生管理系统,管理,管理系统,系统


相关标签/搜索

java培训java是什么javascriptjava面试题及答案2020javascript什么意思javascript基础入门python基础教程基础代谢率计算基础装修基础英语基础知识不扎实的评语基础知识掌握不牢固怎么写评语基础知识和社会工作综合能力c语言基础知识基础知识测试知识付费知识产权知识的拼音梳理是什么意思梳理的拼音梳理机梳理与疏理的区别梳理的近义词配置windows update失败还原更改配置windows update已完成35%请勿关闭计算机配置交换机jdk环境变量配置vscode配置pythonmaven环境变量配置优化营商环境条例优化营商环境nodejs安装及环境配置ubuntu java环境变量ubuntu maven环境变量配置tomcat配置环境变量整型变量用户和权限信息尚未同步完成配置windows update已完成100%完成的英语完成群公告是什么意思刚毕业的大学生怎么找工作浅谈如何在小学语文课堂中培养学生的素养浅谈大学生网络安全1500字学生成长档案系统学生成长档案表格模板学生管理系统学生管理信息系统学生管理系统文档学生管理方面的意见和建议学生管理系统c语言学生管理系统设计学生管理系统课程设计用户和组管理在哪里日志管理系统信息系统项目管理师适应时代发展要求充分运用什么改进党员教育管理工作利用时间管理矩阵可以将每天所面临的事情分为数据库管理系统设备管理系统运维管理系统销售管理系统linux是什么操作系统分布式系统