精华内容
下载资源
问答
  • 黑马Java基础笔记大纲
    万次阅读 多人点赞
    更多相关内容
  • java黑马笔记.rar

    2019-10-08 22:50:22
    java黑java黑马笔记马笔记
  • java黑马学习笔记

    2019-02-21 13:21:19
    是我从黑马资源中抓出来的每天教师上课的笔记,对于基础学习者帮助还是很大的,毕竟视频太多了,不可能全部看完,但是笔记就不一样.
  • 黑马Java基础笔记

    2019-03-18 09:37:18
    非常详细的黑马Java基础核心笔记,非常适合自学的人看!
  • java黑马笔记.rar.rar

    2019-10-09 09:38:21
    java黑马笔记.rar.rar
  • 黑马JavaSE笔记.zip

    2020-11-20 15:20:52
    2020最新黑马Java SE从入门到精通-IDEA版「已完结」1.JAVASE从零开始,深入浅出实战java项目
  • 之前收藏的一个大牛的知识点总结,结合黑马java视频看效果较好,希望能帮助到需要的人
  • 零基础JAVA——黑马程序员课程笔记

    万次阅读 多人点赞 2021-08-03 20:14:46
    JAVA语言发展史 JAVA跨平台原理

    视频地址:点击访问
    (我这里开发工具有时候用eclipse有时候用IDEA,看每个人的习惯)

    (文中代码部分不会和老师讲的一模一样,因为我都是在看到老师给的案例后自己尝试写的,推荐大家这样做,可以帮助大家掌握)

    文章目录

    JAVA语言发展史

    JAVA跨平台原理

    在这里插入图片描述

    JRE和JDK

    JRE (Java Runtime Environment)

    是Java程序的运行时环境,包含JVM和运行时所需要的核心类库。
    我们想要运行一个已有的Java程序, 那么只需安装JRE即可。

    JDK (Java Development Kit)

    是Java程序开发工具包,包含JRE和开发人员使用的工具。
    其中的开发工具:编译工具(javac.exe)和运行工具(java.exe) 。
    我们想要开发一个全新的Java程序,那么必须安装JDK。

    JDK安装目录

    为什么要配置Path环境变量

    开发Java程序,需要使用JDK提供的开发工具,而这些工具在JDK的安装目录的bin目录下。
    为了在开发Java程序的时候,能够方便的使用javac和java这些命令,我们需要配置Path环境变量。

    Java程序开发运行流程

    开发Java程序,需要三个步骤:编写程序,编译程序,运行程序

    空常量不能直接输出

    dos命令

    数据类型


    变量使用的注意事项:

    名字不能重复
    变量未赋值,不能使用
    long类型的变量定义的时候,为了防止整数过大,后面要加L
    float类型的变量定义的时候,为了防止类型不兼容,后面要加F

    标识符定义规则

    ●由数字、字母、下划线( )和美元符($)组成
    ●不能以数字开头
    ●不能是关键字
    ●区分大小写

    常见命名约定

    小驼峰命名法:方法、变量
    ●约定1:标识符是一个单词的时候,首字母小写
    ●范例1:name
    ●约定2: 标识符由多个单词组成的时候,第一个单词首字母小写,其他单词首字母大写
    ●范例2: firstName
    大驼峰命名法:类
    ●约定1: 标识符是一个单词的时候,首字母大写
    ●范例1: Student
    ●约定2: 标识符由多个单词组成的时候,每个单词的首字母大写
    ●范例2: GoodStudent

    类型转换

    自动类型转换

    把一个表示数据范围小的数值或者变量赋值给另-个表示数据范围大的变量
    范例: doubled = 10;

    强制类型转换

    把一个表示数据范围大的数值或者变量赋值给另-个表示数据范围小的变量
    ●格式:目标数据类型变量名= (目标数据类型)值或者变量;
    ●范例: intk = (int)88.88;

    运算符

    算术运算符

    字符的+操作

    package test;
    
    public class test {
        public static void main(String[] args) {
        	int i = 0;
        	char c = 'A';//'A'的值是65
        	System.out.println(i + c);
        }
    }
    

    结果:

    提升规则:

    • byte类型, short类型和char类型将被提升到int类型
    • 整个表达式的类型自动提升到表达式中最等级操作数同样的类型
    • 等级顺序: bvte. short.char->int-> lona-> float > double

    字符串的+操作

    package test;
    
    public class test {
        public static void main(String[] args) {
        	System.out.println("hello"+"earth");
        	System.out.println("hello"+ 6666);
        	System.out.println(6666+ "hello");
        	System.out.println("hello"+6+666);
        	System.out.println(6+666+"hello");
        }
    }
    

    结果:

    赋值运算符


    红色的运算符隐含着强制类型转换

    自增自减运算符


    单独使用

    package test;
    
    public class test {
        public static void main(String[] args) {	
        	//单独使用
        	int i = 1;
        	System.out.println("i="+i);
        	
        	i++;
        	System.out.println("i="+i);
        	
        	++i;
        	System.out.println("i="+i);
        }
    }
    

    结果:

    参与操作使用

    package test;
    
    public class test {
        public static void main(String[] args) {	
        	int i = 1;
        	System.out.println("i="+i);
        	//参与操作使用
        	int j = i++;
        	System.out.println("i="+i);
        	System.out.println("j="+j);    	
        }
    }
    

    结果:

    package test;
    
    public class test {
        public static void main(String[] args) {	
        	int i = 1;
        	System.out.println("i="+i);
        	//参与操作使用
        	int j = ++i;
        	System.out.println("i="+i);
        	System.out.println("j="+j);    	
        }
    }
    

    结果:

    • 参与操作的时候,如果放在变量的后边,先拿变量参与操作,后拿变量做++或者–参与操作的时候,如果放在变量的前边,先拿变量做++或者–,后拿变量参与操作。

    关系运算符

    逻辑运算符

    短路逻辑运算符

    区别:



    注意事项:
    逻辑与&,无论左边真假,右边都要执行。
    短路与&&,如果左边为真,右边执行;如果左边为假,右边不执行。
    逻辑或|,无论左边真假,右边都要执行。
    短路或||,如果左边为假,右边执行;如果左边为真,右边不执行。

    三元运算符


    计算规则:
    首先计算关系表达式的值
    如果值为true,表达式1的值就是运算结果如果值为false,表达式2的值就是运算结果

    数据输入

    Scanner使用的基本步骤

    package test;
    
    import java.util.Scanner;
    
    public class test {
        public static void main(String[] args) {	
        	Scanner sc = new Scanner(System.in);
        	int i = sc.nextInt();
        	System.out.println("i="+i);
        	sc.close();//关闭sc接口
        }
    }
    
    

    结果:

    流程控制

    分支结构

    if语句

    public class test {
        public static void main(String[] args) {	
     	Scanner sc = new Scanner(System.in);
        	int a = sc.nextInt();
        	if (a % 2 == 0)
        		System.out.println("a是偶数");
        	else
        		System.out.println("a是奇数");
        	sc.close();
        }
    }
    

    结果:

    switch语句

    输入一个数字判断是什么季节

    public class test {
        public static void main(String[] args) {	
       	Scanner sc = new Scanner(System.in);
        	int i = sc.nextInt();
        	switch (i) {
        	case 1:
        		System.out.println("春季");
        		break;
        	case 2:
        		System.out.println("春季");
        		break;
        	case 3:
        		System.out.println("春季");
        		break;
        	case 4:
        		System.out.println("夏季");
        		break;
        	case 5:
        		System.out.println("夏季");
        		break;
        	case 6:
        		System.out.println("夏季");
        		break;
        	case 7:
        		System.out.println("秋季");
        		break;
        	case 8:
        		System.out.println("秋季");
        		break;
        	case 9:
        		System.out.println("秋季");
        		break;
        	case 10:
        		System.out.println("冬季");
        		break;
        	case 11:
        		System.out.println("冬季");
        		break;
        	case 12:
        		System.out.println("冬季");
        		break;
        	default:
        		System.out.println("输入不合法");
        		break;
        	}
        	sc.close();
        }
    }	
    

    利用case穿透性

    //case穿透
    public class test {
            public static void main(String[] args) {	
        	Scanner sc = new Scanner(System.in);
        	int i = sc.nextInt();
        	switch (i) {
        	case 1:
        	case 2:
        	case 3:
        		System.out.println("春季");
        		break;
        	case 4:
        	case 5:
        	case 6:
        		System.out.println("夏季");
        		break;    		
        	case 7:
        	case 8:
        	case 9:
        		System.out.println("秋季");
        		break;   
        	case 10:
        	case 11:
        	case 12:
        		System.out.println("冬季");
        		break; 
        	default:
        		System.out.println("输入不合法");
        	}
        	sc.close();
        }
    }	
    

    循环结构

    for语句

    经典案例:

    public class test {
            public static void main(String[] args) {	
    //先找到100——999
        	for(int i = 100;i < 1000;i++) {
        		//判断条件
        		int a = i % 10;
        		int b = i / 10 % 10;
        		int c = i / 100 % 10;
        		if(a*a*a+b*b*b+c*c*c == i) {
        			System.out.println(i);
        		}
        	}
        }
    }	
    

    结果:

    while语句

    在这里插入图片描述

    
    public class test {
            public static void main(String[] args) {
        	int i = 0;
        	double hou = 0.1;
        	while(hou <=8844430) {
        		i++;
        		hou = hou*2;
        	}
        	System.out.println(i);
        }
    }	
    

    结果:

    三种循环的区别

    Random作用和使用步骤

    作用:产生一个随机数

    猜数字案例

    package test;
    import java.util.Random;
    import java.util.*;
    
    
    public class test1 {
    	public static void main(String []args ) {
    		Random r = new Random();
    		int num = r.nextInt(100)+1;
    		System.out.println(num);
    		Scanner sc = new Scanner(System.in);
    		while(true) {
    		int num1 = sc.nextInt();
    		if(num > num1) {
    			System.out.println("需要猜大一点");
    		}else if(num < num1) {
    			System.out.println("需要猜小一点");
    		}else {
    			System.out.println("猜对了,你真厉害");
    			break;
    		}
    	}
    	}
    }
    

    结果:

    数组

    数组定义格式

    什么是数组

    数组(array)是一种用于存储多个相同类型数据的存储模型

    数组定义格式

    数组初始化之动态初始化

    数组初始化概述

    Java中的数组必须先初始化然后才能使用
    所谓初始化:就是为数组中的数组元素分配内存空间,并为每个数组元素赋值

    数组初始化方式

    动态初始化和静态初始化

    动态初始化

    动态初始化:初始化时只指定数组长度,由系统为数组分配初始值。

    • int:说明数组中元素的类型是int
    • [ ]:说明这是一个数组
    • arr:这是数组的名称
    • new:为数组申请内存空间
    • int:说明数组中元素的类型是int
    • [ ]:说明这是一个数组
    • 3:数组长度,其实就是数组中的元素个数

    数组元素访问

    public class test1 {
    	public static void main(String []args ) {
        	int[] arr = new int [5];
    		//输出数组名
    		System.out.println(arr);
    		//输出数组元素
    		System.out.println(arr[0]);
    	}
    }
    

    结果:

    内存分配

    Java中内存分配

    Java程序在运行时,需要在内存中分配空间。为了提高运算效率,就对空间进行了不同区域的划分,因为每一片区域都有特定的处理数据方式和内存管理方式。

    ***这里arr指向的是内存地址,这个内存地址是首地址(数组首地址)***

    数组初始化之静态初始化

    静态初始化:初始化时指定每个数组元素的初始值,由系统决定数组长度

    public class test1 {
    	public static void main(String []args ) {
    		int[] arr = {1,2,3};
    		int[] arr1 = {3,2,1};
    		System.out.println(arr);
    		System.out.println(arr[0]);
    		System.out.println(arr1);
    		System.out.println(arr1[0]);
    	}
    }
    

    结果:

    数组操作的两个常见小问题

    public class test1 {
    	public static void main(String []args ) {
    		int[] arr = new int[3];
    		System.out.println(arr);
    		System.out.println(arr[0]);
    		arr = null;
    		System.out.println(arr);
    		System.out.println(arr[0]);
    	}
    }
    

    结果:

    发生空指针异常,当arr = null时,指针不再有指向。

    数组常见操作

    遍历

    public class test1 {
    	public static void main(String []args ) {
    		int[] arr = {1,2,3,4,5,6};
    		for(int i = 0;i < arr.length;i++) {
    			System.out.println(arr[i]);
    		}
    	}
    }
    
    

    结果:

    获取最值

    public class test1 {
    	public static void main(String []args ) {
    //获取最值
    		//定义一个数组
    		int[] arr = {3,1,2,4};
    		//定义存放最大值,令他等于数组第一个元素
    		int max = arr [0];
    		//循环比较找出真正的最大值
    		for(int i = 1;i < arr.length;i++) {
    			if(max <= arr[i]) {
    				max = arr[i];
    			}
    		}
    		System.out.println(max);
    	}
    }
    

    结果:

    方法

    方法概述

    什么是方法

    方法(method)是将具有独立功能的代码块组织成为一个整体,使其具有特殊功能的代码集
    注意:

    • 方法必须先创建才可以使用,该过程称为方法定义
    • 方法创建后并不是直接运行的,需要手动使用后才执行,该过程称为方法调用

    方法的定义和调用

    方法定义

    方法调用

    • 判断输入的数字是否是偶数(在视频讲解的基础上自己稍稍调整的代码)
    public class test1 {
    	public static void main(String []args ) {
    		Scanner sc = new Scanner(System.in);
    		int a = sc.nextInt();
    		//函数调用
    		isnumber(a);
    		sc.close();
    	}
    //定义判断是否是偶数的方法
    public static void isnumber(int i) {
    			if(i % 2 == 0) {
    				System.out.println("是偶数");
    			}else {
    				System.out.println("不是偶数");
    			}
    		}
    }
    

    结果:

    • 判断数组中的最大元素(在视频讲解的基础上自己稍稍调整的代码)
    public class test1 {
    	public static void main(String []args ) {
    		int[] arr = {1,5,2,3,7};
    		getmax(arr);
    	}
    	//获取数组中最大数
    	public static void getmax(int i[]) {
    		int max = i[0];
    		for(int a = 1;a < i.length;a++) {
    			if(max <= i[a]) {
    				max = i[a];
    			}
    		}
    		System.out.println(max);
    	}
    }
    

    结果:

    带返回值方法的定义和调用

    带返回值方法定义

    • 方法定义时return后面的返回值与方法定义上的数据类型要匹配,否则程序将报错
    • 方法的返回值通常会使用变量接收,否则该返回值将无意义

    方法的注意事项

    方法注意事项

    • 方法不能嵌套定义
    • void表示无返回值,可以省略return,也可以单独的书写return,后面不加数据

    方法的通用格式


    定义方法时,要做到两个明确

    • 明确返回值类型:主要是明确方法操作完毕之后是否有数据返回,如果没有,写void;如果有,写对应的数据类型明确参数:主要是明确参数的类型和数量
    • 调用方法时
      void类型的方法,直接调用即可
      非void类型的方法,推荐用变量接收调用

    方法重载

    方法重载指同一个类中定义的多个方法之间的关系,满足下列条件的多个方法相互构成重载

    • 多个方法在同一个类中
    • 多个方法具有相同的方法名
    • 多个方法的参数不相同,类型不同或者数量不同


    ###重载实例
    需求:使用方法重载的思想,设计比较两个整数是否相同的方法,兼容全整数类型(byte,short,intlong)

    public class test1 {
    	public static void main(String []args ) {
    		boolean a = compare(1,2);
    		System.out.println(a);
    		boolean c = compare((byte)1,(byte)2);//类型转换
    		System.out.println(c);
    		boolean b = compare(2.0,2.0);
    		System.out.println(b);
    	}
    	//定义比较两个数字是否相同
    	public static boolean compare(int a,int b) {
    		System.out.println("int");
    		return(a == b);
    	}
    	public static boolean compare(double a,double b) {
    		System.out.println("double");
    		return(a == b);
    	}
    	public static boolean compare(byte a,byte b) {
    		System.out.println("byte");
    		return(a == b);
    	}
    }
    
    

    结果:

    方法的参数传递

    了解形参与实参可以参考其它作者文章:点击查看
    基本类型和引用类型的区别:基本数据类型在声明时系统就给它分配空间;而引用数据类型不同,它声明时只给变量分配了引用空间,而不分配数据空间。
    通常 基本类型 和 String 传递是值传递,形参的改变不会影响实参的改变

    方法参数传递(基本类型)

    对于基本数据类型的参数。形式参数的改变,不影响实际参数的值

    结果:

    理解
    在调用change方法的时候,知识将main方法中的值传给对应的形式参数,函数接收的是原始值的一个拷贝, 此时内存中存在两个相等的基本类型,后面方法中的操作都是对形参这个值的修改,不影响实际参数的值。

    方法参数传递(引用类型)

    对于引用类型的参数,形式参数的改变,影响实际参数的值

    结果:

    理解
    在调用change方法的时候,形参和实参都指向相同的内存地址,所以对形参的修改就是对所指向地址空间数据的修改,此时实参也会发生改变

    案例

    public class test1 {
    	public static void main(String []args ) {
    		int[] arr = {1,2,4,5,3,6,9};
    		show(arr);
    	}
    	public static void show(int[] a) {
    		System.out.print("[");
    		for(int i = 0;i < a.length;i++) {
    			if(i == a.length-1) {
    				System.out.print(a[i]);
    			}else {
    				System.out.print(a[i]+",");
    			}
    		}
    		System.out.print("]");
    	}
    }
    

    结果:

    Debug(IDEA演示)

    Debug操作流程

    Debug调试,又被称为断点调试,断点其实是一个标记,告诉我们从哪里开始查看

    1. 如何加断点
      点击你想要添加断点的代码的前方
    2. 如何运行加了断点的程序
      点击右键,选择debug
    3. 看哪里
    4. 点哪里
      点击执行,观察窗口的变化
    5. 如何删除断点

    Debug使用

    这一部分难度不大,建议自己看视频操作一下,很容易掌握

    阶段综合案例(这里我只做了部分)

    减肥问题(会穿插==和equal()使用的知识)

    这里我想在视频的基础上实现输入的不是数字,而是”星期一“这样的字符串,但在进行字符串比较时出现了问题,如下图:

    当我在控制台输入”星期一“后,显示如下图:

    并没有像我想的一样成功打印出”跑步“,之后我进行debug发现,没有进行进入循环,说明不符合判断条件,但在我理解中应该是符合判断条件的,这时我把判断条件单独拿出来运行:

    当我在控制台输入”星期一“时,输出false

    看来不符合判断条件,这里使用连等号不能达到我们的目的
    经过搜索资料我发现: 连等号在比较基本数据类型时比较的是值即以下类型比较时是比较的值。具体深入理解java中==和equals的用法可以查看其它作者的文章:点击查看


    修改后:

    最终可以达到目的,这里只做部分的代码呈现,大家可以自己完整做一下,亲手做才会有收获哦,发现问题解决问题。

    不死神兔


    public class test {
        public static void main(String[] args) {
            int[] arr = new int[20];
            arr[0] = 1;
            arr[1] = 1;
            for (int i = 2;i < arr.length;i++){
                arr[i] = arr[i-2] + arr[i-1];
            }
            System.out.println(arr[19]);
    
        }
    }
    

    结果:

    百钱百鸡


    这里我没有采用视频中奖的方法,视频中的方法可以去具体看一下老师讲的(第93个问题)
    这里我没有对三种鸡的数量进行分析,只是令所有的数量都小于100,if后用来写约束条件

    结果:

    但是这里我遗忘了一个条件,小鸡仔的数量卖的时候必须是三个三个卖的,因此小鸡仔的数量必须是3的倍数
    由此我做出改进

    结果:

    数组内容相同

    public class test {
        public static void main(String[] args) {
            //定义两个数组
            int[] arr = {1,2,3,4};
            int[] arr1 = {1,2,3,4};
            System.out.println(compare(arr,arr1));
    
        }
        public static boolean compare(int[] a,int[] b){
            //当长度不同时不需要一一比较就可以判断
            if (a.length != b.length){
                return false;
            }
            for(int i = 0;i < a.length;i++){
                if (a[i] != b[i]){
                    return false;
                }
            }
            return true;
        }
    }
    

    结果:

    反转


    public class test {
        public static void main(String[] args) {
            //1:定义一个数组,用静态初始化完成数组元素的初始化
            int[] arr = {1,2,3,4};
            //2:循环遍历数组,这一次初始化语句定义两个索引变量,判断条件是开始索引小于等于结束索引
            for (int start=0,end = arr.length-1;start<=end;start++,end--){
                //3:变量交换
                int temp = arr[start];
                arr[start] = arr[end];
                arr[end] = temp;
            }
            show(arr);
    
        }
        //4:遍历数组
        public static void show(int[] a) {
            System.out.print("[");
            for(int i = 0;i < a.length;i++) {
                if(i == a.length-1) {
                    System.out.print(a[i]);
                }else {
                    System.out.print(a[i]+",");
                }
            }
            System.out.print("]");
        }
    }
    

    结果:

    面向对象基础

    类和对象

    什么是对象

    万物皆对象,客观存在的事物皆为对象

    什么是类

    类是对现实生活中一类具有共同属性和行为的事物的抽象
    (类在现实中不存在)
    类的特点:

    • 类是对象的数据类型
    • 类是具有相同属性和行为的一组对象的集合

    什么是对象的属性

    属性:对象具有的各种特征,每个对象的每个属性都拥有特定的值

    什么是对象的行为

    行为:对象能够执行的操作

    类和对象的关系

    类:类是对现实生活中一类具有共同属性和行为的事物的抽象
    对象:是能够看得到摸的着的真实存在的实体

    类的定义

    • 类的重要性:是Java程序的基本组成单位
    • 类是什么:是对现实生活中一类具有共同属性和行为的事物的抽象,确定对象将会拥有的属性和行为
    • 类的组成:属性和行为
      属性:在类中通过成员变量来体现(类中方法外的变量)
      行为:在类中通过成员方法来体现(和前面的方法相比去掉static关键字即可)

    对象的使用

    package com.java;
    
    public class PhoneDemo {
        public static void main(String[] args){
            //创建对象
            Phone p = new Phone();
    
            //使用成员变量
            System.out.println(p.brand);
            System.out.println(p.price);
    
            p.brand = "华为";
            p.price = 2999;
    
            System.out.println(p.brand);
            System.out.println(p.price);
    
            //使用成员方法
            p.call();
            p.sendMessage();
        }
    
    }
    

    结果:

    案例



    结果:

    对象内存图

    查看堆和栈的相关信息可以看其它作者的文章:点击查看

    对象内存图(单个对象)

    对象内存图(多个对象)

    对象内存图(多个对象指向相同)

    成员变量和局部变量

    成员变量与局部变量的区别

    封装

    private关键字

    • 是一个权限修饰符
    • 可以修饰成员(成员变量和成员方法)
    • 作用是保护成员不被别的类使用,被private修饰的成员只在本类中才能访问
    • 针对private修饰的成员变量,如果需要被其他类使用,提供相应的操作
    • 提供“get变量名()”方法,用于获取成员变量的值,方法用public修饰提供“set变量名(参数)”方法,用于设置成员变量的值,方法用public修饰

    private关键字的使用



    结果:

    this关键字

    什么时候使用this呢? 解决局部变量隐藏成员变量
    Student类写作这样

    在运行测试类后结果是:

    因为在setAge方法中指代不清楚,导致认为age都是局部变量。进行如下修改

    用this来指代成员变量就会避免冲突,达到预想的效果。结果:

    封装

    1.封装概述
    是面向对象三大特征之一(封装,继承,多态)
    是面向对象编程语言对客观世界的模拟,客观世界里成员变量都是隐藏在对象内部的,外界是无法直接操作的
    2.封装原则
    将类的某些信息隐藏在类内部,不允许外部程序直接访问,而是通过该类提供的方法来实现对隐藏信息的操作和访问成员变量private,提供对应的getXxox()/setXxx()方法
    3.封装好处
    通过方法来控制成员变量的操作,提高了代码的安全性把代码用方法进行封装,提高了代码的复用性

    构造方法





    结果:

    构造方法注意事项


    可能大家会疑问,为什么之前没有给出构造方法,仍然可以这样使用上述语句:那是因为在没有给出构造方法的时候,系统默认给出无参构造方法。

    • 构造方法的创建
      如果没有定义构造方法,系统将给出一个默认的无参数构造方法如果定义了构造方法,系统将不再提供默认的构造方法
    • 构造方法的重载
      如果自定义了带参构造方法,还要使用无参数构造方法,就必须再写一个无参数构造方法
    • 推荐的使用方式
      无论是否使用,都手工书写无参数构造方法



    结果:

    标准类的制作


    做好下边实例可以带大家充分了解构造方法:

    public class Student {
        //成员变量
        private String name;
        private int age;
        //构造方法
        public Student(){
            System.out.println("无参构造方法");
        }
    
        public Student(String name,int age){
            this.age = age;
            this.name = name;
        }
        //set/get方法
        public void setName(String name){
            this.name = name;
        }
        public String getName(){
            return name;
        }
        public void setAge(int age){
            this.age = age;
        }
        public int getAge(){
            return age;
        }
    
        //成员方法
        public void show(){
            System.out.println(name+age);
        }
    }
    

    测试类

    public class StudentTest {
        public static void main(String[] args){
            //无参构造方法,再使用setXX赋值
            Student a = new Student();
            a.setName("小怪兽");
            a.setAge(12);
            a.show();
            System.out.println("____________");
            //带参构造方法直接创建有属性的对象
            Student b = new Student("奥特曼",100);
            b.show();
        }
    }
    

    结果:

    字符串

    API

    API概述


    帮助文档的使用可以查看我最上边给出的视频中的讲解,个人比较喜欢直接百度搜索。

    注意:
    调用方法的时候,如果方法有明确的返回值,我们用变量接收可以手动完成,也可以使用快捷键的方式完成(Ctrl+Alt+V)

    String

    String概述

    String构造方法

    public class test {
        public static void main(String[] args){
            //String构造方法:
            //public string( ):创建一个空白字符串对象,不含有任何内容
            String a = new String();
            System.out.println("a:"+a);
            //public String(char[] chs):根据字符数组的内容,来创建字符串对象
            char[] arr = {'a','b','c'};
            String b = new String(arr);
            System.out.println("b:"+b);
            //public String(byte[] bys):根据字节数组的内容,来创建字符串对象
            byte[] arr1 = {99,98,97};
            String c = new String(arr1);
            System.out.println("c:"+c);
            // 没有使用构造方法,String s =“abc”;直接赋值的方式创建字符串对象,内容就是abc
            String d = "coco";
            System.out.println("d:"+d);
        }
    }
    
    


    结果:

    但是推荐使用直接赋值方式

    String对象特点

    1. 通过new创建的字符串对象,每一次new都会申请一个内存空间,虽然内容相同,但是地址值不同

    上面的代码中,JVM会首先创建一个字符数组,然后每一次new的时候都会有一个新的地址,只不过s1和s2参考的字符串内容是相同的

    1. 以"”方式给出的字符串,只要字符序列相同(顺序和大小写),无论在程序代码中出现几次,JVM都只会建立一个String 对象,并在字符串池中维护

      在上面的代码中,针对第一行代码,JVM会建立一个String对象放在字符串池中,并给s3参考;第二行则让s4直接参考字符串池中的String对象,也就是说它们本质上是同一个对象

    字符串比较


    想看具体==和equal()的用法可以参考我前边给到的讲解:点击跳转

    public class test {
        public static void main(String[] args){
            char[] arr = {'a','b','c'};
            String s1 = new String(arr);
            String s2 = new String(arr);
    
            String s3 = "abc";
            String s4 = "abc";
    
            System.out.println(s1==s2);
            System.out.println(s1==s3);
            System.out.println(s3==s4);
            System.out.println("````````````````````````");
            System.out.println(s1.equals(s2));
            System.out.println(s1.equals(s3));
            System.out.println(s3.equals(s4));
        }
    }
    

    结果:

    案例

    用户登录


    我的代码和课程上的有一点点出入,可以都尝试一下

    public class test {
        public static void main(String[] args){
            //预先给出用户名和密码
            String name = "小怪兽";
            String code = "123abc";
            for(int i = 1;i <= 3;i++){
                Scanner sc = new Scanner(System.in);
                System.out.println("输入用户名:");
                String name1 = sc.nextLine();
                System.out.println("输入密码:");
                String code1 = sc.nextLine();
                if (name.equals(name1)&&code.equals(code1)){
                    System.out.println("成功登录!欢迎"+name);
                    break;
                }else if (name.equals(name1)){
                    System.out.println("密码输入错误");
                }else if (code.equals(code1)){
                    System.out.println("用户名输入错误");
                }else{
                    System.out.println("用户名和密码输入错误");
                }
            }
        }
    }
    

    结果:

    遍历字符串

    import java.util.Scanner;
    
    public class test1 {
        public static void main(String[] args){
            Scanner sc = new Scanner(System.in);
            System.out.println("输入一个字符串:");
            String s = sc.nextLine();
            for(int i = 0;i < s.length();i++){
                //获取指定索引处的char值
                char a = s.charAt(i);
                System.out.print(a+" ");
            }
        }
    }
    
    

    结果:

    统计字符次数

    import java.util.Scanner;
    
    public class test1 {
        public static void main(String[] args){
              Scanner sc = new Scanner(System.in);
              System.out.println("输入一个字符串:");
              String s = sc.nextLine();
              int bigcount = 0;
              int smallcount = 0;
              int numbercount = 0;
              for (int i = 0;i < s.length();i++){
                  char a = s.charAt(i);
                  if (a >='A'&& a<='Z'){
                      bigcount++;
                  }else if (a >= 'a' && a <= 'z'){
                      smallcount++;
                  }else if (a >= '0' && a <= '9'){
                      numbercount++;
                  }
              }
             System.out.println("大写字母:"+bigcount);
             System.out.println("小写字母:"+smallcount);
             System.out.println("数字:"+numbercount);
        }
    }
    

    结果:

    拼接字符串

    public class test2 {
        public static void main(String[] args){
            //预先初始化一个数组
            int[] arr = {2,5,2,7};
            //调用方法
            String n = show(arr);
            System.out.println(n);
        }
        //定义一个方法来输出
        public static String show(int[] a){
            String s = "[";
            for (int i = 0;i <a.length;i++){
                if (i == a.length-1){
                    s = s + a[i];
                }else{
                    s = s + a[i]+",";
                }
            }
            s = s + "]";
            return s;
        }
    }
    

    结果:

    最后有一个案例是字符串反转,和前边的数组反转有异曲同工之妙,大家可以自己尝试一下

    StringBuilder

    StringBuilder概述


    如果对字符串进行拼接操作,每次拼接,都会构建一个新的String对象,既耗时,又浪费内存空间,而这种操作还不可避免。那么有没有一种比较好的方式可以解决这个问题呢?答案是肯定的,我们可以通过Java提供的StringBuilder类就来解决这个问题。

    StringBuilder是一个可变的字符串类,我们可以把它看成是一个容器
    这里的可变指的是StringBuilder对象中的内容是可变的

    String和StringBuilder的区别:
    String:内容是不可变的StringBuilder:内容是可变的

    StringBuilder构造方法



    结果:

    StringBuilder的添加和反转方法



    结果:

    这里可以明显的看出来,a,b是同一个对象。帮助我们很好的理解了什么是返回对象本身。

    结果:


    结果:

    因为append()返回的是对象本身,而对象可以调用方法,所以可以连续调用,让返回值作为对象调用方法

    结果:

    StringBuilder 和String相互转换

    1.StringBuilder转换为String
    publicString toString():通过 toString()就可以实现把StringBuilder转换为String
    2.String转换为StringBuilder
    public StringBuilder(String s):通过构造方法就可以实现把String转换为StringBuilder

    结果:

    可以从输出的结果看出来toString()可以实现把StringBuilder转换为String

    结果:

    案例

    拼接字符串


    一开始我没有想到通过转换最终用String接收结果,下面是我的方法:

    
    public class test1 {
        public static void main(String[] args){
            //初始化数组
            int[] arr={2,3,4,5};
            System.out.println(combine(arr));
        }
        //定义拼接字符串方法
        public static StringBuilder combine(int[] a){
            StringBuilder s = new StringBuilder();
            s.append("[");
            for (int i = 0;i < a.length;i++){
                if (i == a.length-1){
                    s.append(a[i]);
                }else {
                    s.append(a[i]).append(",");
                }
            }
            s.append("]");
            return s;
        }
    
    }
    

    结果:

    改进后:

    package stringbulider;
    
    public class test1 {
        public static void main(String[] args){
       
            //初始化数组
            int[] arr={2,3,4,5};
            String s = combine(arr);
            System.out.println(s);
        }
        //定义拼接字符串方法
        public static String combine(int[] a){
            StringBuilder s = new StringBuilder();
            s.append("[");
            for (int i = 0;i < a.length;i++){
                if (i == a.length-1){
                    s.append(a[i]);
                }else {
                    s.append(a[i]).append(",");
                }
            }
            s.append("]");
            String c = s.toString();
            return c;
        }
    }
    

    字符串反转


    这里我没有使用方法,无法复用

    package stringbulider;
    
    import java.util.Scanner;
    
    public class test2 {
        public static void main(String[] args){
            Scanner sc = new Scanner(System.in);
            System.out.println("输入一段字符串:");
            String a = sc.nextLine();
            //把它转化为StingBulider后使用
            StringBuilder s = new StringBuilder(a);
            System.out.println(a+"字符串反转结果为:"+s.reverse());
        }
    }
    

    结果:

    构造方法后:

    import java.util.Scanner;
            Scanner sc = new Scanner(System.in);
            System.out.println("输入一段字符串:");
            String a = sc.nextLine();
            String b = change(a);
            System.out.println(a+"字符串反转结果为:"+ b);
        }
        public static String change(String a){
            return new StringBuilder(a).reverse().toString();
        }
    }
    

    集合基础

    集合概述


    集合类的特点:提供一种存储空问可变的存储模型,存储的数据容量可以发生改变集合类有很多,目前我们先学习一个: ArrayList

    ArrayList构造方法和添加方法



    结果:

    ArrayList常用方法

    public boolean remove(0bject o):删除指定的元素,返回删除是否成功
    结果:


    结果:

    public E remove(int index):删除指定索引处的元素,返回被删除的元素

    结果:


    结果:

    这里出现了索引越界
    public E set(int index,E element):修改指定索引处的元素,返回被修改的元素

    结果:

    public E get(int index):返回指定索引处的元素

    结果:

    案例

    存储字符串并遍历

    package com.collection;
    
    import java.util.ArrayList;
    
    public class test {
        public static void main(String[] args) {
            ArrayList<String> array = new ArrayList<String>();
            array.add("小怪兽");
            array.add("奥特曼");
            array.add("哈利波特");
            System.out.println("array:"+array);
            for (int i = 0;i < array.size();i++){
                //这里视频是采用的用字符串接受
                System.out.println("第"+(i+1)+"个元素是:"+array.get(i));
            }
        }
    }
    

    结果:

    存储学生对象并遍历

    package com.collection;
    
    import java.util.ArrayList;
    
    public class test2 {
        public static void main(String[] args) {
            //创建集合对象
            ArrayList<Student> array = new ArrayList<Student>();
            //创建学生对象
            Student a = new Student("coco",11);
            Student b = new Student("小怪兽",11);
            Student c = new Student("奥特曼",22);
    
            //添加学生对象到集合中
            array.add(a);
            array.add(b);
            array.add(c);
    
            for (int i = 0;i < array.size();i++){
                Student s = array.get(i);
                System.out.println("第"+(i+1)+"个学生:"+s.getName()+" "+s.getAge());
            }
    
        }
    }
    

    结果:

    改进后

    package com.collection;
    
    import java.util.ArrayList;
    import java.util.Scanner;
    
    public class test2 {
        public static void main(String[] args) {
            //创建集合对象
            ArrayList<Student> array = new ArrayList<Student>();
            //创建学生对象
            addStudent(array);
            addStudent(array);
            addStudent(array);
    
            for (int i = 0;i < array.size();i++){
                Student s = array.get(i);
                System.out.println("第"+(i+1)+"个学生:"+s.getName()+" "+s.getAge());
            }
    
        }
        public static void addStudent(ArrayList<Student> array){
            Scanner sc = new Scanner(System.in);
            System.out.print("输入名字:");
            String name = sc.nextLine();
            System.out.print("输入年龄:");
            String age = sc.nextLine();
            Student s = new Student();
            s.setName(name);
            s.setAge(age);
            array.add(s);
        }
    }
    

    结果:

    学生管理系统

    当我们从键盘上循环输入一段字符串时要采用next()而不是nextLine(),因为nextLine()上次输入的值后会有/n会被下次循环输入时接受,错误判定为结束,会出现跳过现象。
    Student.java

    package system;
    
    public class Student {
        //学号
        private String sid;
        //姓名
        private String name;
        //年龄
        private String age;
        //居住地
        private String address;
    
        public Student(){}
        public Student(String sid,String name,String age,String address){
            this.sid = sid;
            this.name = name;
            this.age = age;
            this.address = address;
        }
        public void setSid(String sid){
            this.sid = sid;
        }
        public String getSid(){return sid;}
        public void setName(String name){
            this.name = name;
        }
        public String getName(){return name;}
        public void setAge(String age){
            this.age = age;
        }
        public String getAge(){return  age;}
        public void setAddress(String address){
            this.address = address;
        }
        public String getAddress(){return address;}
    }
    
    

    main.java

    package system;
    
    import java.util.ArrayList;
    import java.util.Scanner;
    
    public class main {
        public static void main(String[] args) {
            //集合对象
            ArrayList<Student> array = new ArrayList<Student>();
            while(true){
                MainInterfance();
                Scanner sc = new Scanner(System.in);
                int num = sc.nextInt();
                switch (num){
                    case 1:
                        System.out.println("添加学生");
                        addStudent(array);
                        break;
                    case 2:
                        System.out.println("删除学生");
                        deleteStudent(array);
                        break;
                    case 3:
                        System.out.println("修改学生");
                        alterStudent(array);
                        break;
                    case 4:
                        System.out.println("查看所有学生");
                        showStudent(array);
                        break;
                    case 5:
                        System.out.println("感谢您的使用!");
                        System.exit(0);
                }
            }
    
        }
        //主页面
        public static void MainInterfance(){
            System.out.println("-------------欢迎来到学生管理系统-------------");
            System.out.println("1.添加学生");
            System.out.println("2.删除学生");
            System.out.println("3.修改学生");
            System.out.println("4.查看所有学生");
            System.out.println("5.退出");
            System.out.println("请输入你的选择:");
        }
        //添加学生
        public static void addStudent(ArrayList<Student> array){
            System.out.print("请输入你想添加学生的个数:");
            Scanner sc = new Scanner(System.in);
            int num = sc.nextInt();
            for (int i = 1;i <= num;i++){
                System.out.println("输入添加的第"+i+"个学生的信息");
                String sid;
                while (true){
                    System.out.println("输入学号:");
                    sid = sc.next();
                    boolean a = decide(sid,array);
                    if (a){
                        System.out.println("该学号已存在,请重新输入!");
                    }else {
                        break;
                    }
                }
    
                System.out.println("输入姓名:");
                String name = sc.next();
                System.out.println("输入年龄:");
                String age = sc.next();
                System.out.println("输入居住地:");
                String address = sc.next();
                Student s = new Student();
                s.setSid(sid);s.setAge(age);s.setName(name);s.setAddress(address);
                array.add(s);
            }
            System.out.println("添加成功!");
        }
        //删除学生
        public static void deleteStudent(ArrayList<Student> array){
            Scanner sc = new Scanner(System.in);
            System.out.println("输入你想删除的学生的学号:");
            String sid = sc.next();
            for (int i = 0;i < array.size();i++){
                Student s = array.get(i);
                if (s.getSid().equals(sid)){
                    array.remove(i);
                    break;
                }else{
                    System.out.println("您输入的学生不存在!");
                    break;
                }
    
    
            }
        }
        //修改学生
        public static void alterStudent(ArrayList<Student> array) {
            Scanner sc = new Scanner(System.in);
            System.out.println("输入你想修改的学生的学号:");
            String sid = sc.next();
            System.out.println("输入新姓名:");
            String name = sc.next();
            System.out.println("输入新年龄:");
            String age = sc.next();
            System.out.println("输入新居住地:");
            String address = sc.next();
            Student s = new Student();
            s.setSid(sid);s.setAge(age);s.setName(name);s.setAddress(address);
            for (int i = 0; i < array.size(); i++) {
                Student student = array.get(i);
                if (student.getSid().equals(sid)) {
                    array.set(i,s);
                    break;
                }
    
            }
        }
        //查看学生
        public static void showStudent(ArrayList<Student> array){
            if (array.size() == 0){
                System.out.println("当前没有学生,请先添加学生。");
            }
            System.out.println("学号 "+" 姓名 "+" 年龄 "+" 居住地");
            for(int i = 0;i < array.size();i++){
                Student s = array.get(i);
                System.out.println(s.getSid()+"  "+s.getName()+"  "+s.getAge()+"  "+s.getAddress());
            }
        }
        //判断学号重复
        public static boolean decide(String sid,ArrayList<Student> array){
            boolean a = false;
            for (int i = 0;i < array.size();i++){
                Student s = array.get(i);
                if(sid.equals(s.getSid())){
                    a = true;
                    break;
                }
            }
            return a;
        }
    
    }
    
    

    结果:(添加和查看)

    结果:(删除和修改)

    继承

    继承概述

    继承是面向对象三大特征之一。可以使得子类具有父类的属性和方法,还可以在子类中重新定义,追加属性和方法

    继承的好处和弊端

    好处:

    • 提高了代码的复用性
    • 提高了代码的维护性
      弊端:
      继承让类与类之间产生了关系,类的耦合性增强了,当父类发生变化时子类实现也不得不跟着变化,削弱了子类的独立性

    继承中变量的访问特点

    在子类方法中访问一个变量

    • 子类局部范围找
    • 子类成员范围找父类成员范围找

    super

    super关键字的用法和this关键字的用法相似
    this:代表本类对象的引用
    super:代表父类存储空间的标识(可以理解为父类对象引用)

    随着我的学习更新

    展开全文
  • 黑马程序员Java教程学习笔记(一)

    千次阅读 2022-01-11 16:37:24
    文章目录黑马程序员Java学习笔记Java版本Java语言的跨平台原理JRE和JDKJDK的下载和安装HelloWorld案例注释关键字常量数据类型标识符类型转换运算符字符"+"操作字符串"+"操作复制运算符自增自减运算符关系运算符逻辑...


    黑马程序员Java学习笔记

    Java版本

    • Java(5.0):是更新力度很大的一个版本,直接让Java的发展进入了快车道

    • Java(8.0):是公司中生产/开发环境使用的最多的版本

    • Java(11.0):是Java学习者使用的最多的版本

    Java语言的跨平台原理

    在需要运行Java应用程序的操作系统上,安装一个与操作系统相对应的Java虚拟机(JVM Java Virtual Machine)即可。

    JRE和JDK

    • JRE(Java Runtime Environment)

      是Java程序的运行时环境,包含JVM和运行时所需要的核心类库

      只是想要运行一个Java程序,那么只需要安装JRE即可。

    • JDK(Java Development Kit)

      是Java程序开发工具包,包含JRE和开发人员使用的工具。

      其中的开发工具:编译工具(javac.exe)和运行工具(java.exe)

    JDK、JRE、JVM的关系如下图:
    在这里插入图片描述

    JDK的下载和安装

    Java11 for WIndows: https://www.oracle.com/java/technologies/downloads/#java11-windows

    JDK的安装目录

    目录名称说明
    bin该路径下存放了JDK的各种工具命令。javacjava就在这个目录
    conf该路径下存放了JDK的相关配置文件
    include该路径下存放了一些平台特定的头文件
    jmods该路径下存放了JDK的各种模块
    legal该路径下存放了JDK各模块的授权文档
    lib该路径下存放了JDK工具的一些补充JAR包
    其他其余文件为说明性文档

    HelloWorld案例

    HelloWorld.java

    public class HelloWorld {
    	public static void main(String[] args) {
    		System.out.println("Hello World");
    	}
    }
    
    D:\Java\mycode>javac HelloWorld.java
    
    D:\Java\mycode>java HelloWorld
    Hello World
    
    D:\Java\mycode>
    

    注释

    • 单行注释
      格式:	//注释信息
      
    • 多行注释
      格式:	
      /*
      注释信息
      注释信息
      */
      
    • 文档注释
      格式:	
      /**
      注释信息
      */
      
    /*
    	Java程序中最基本的组成单位是类。
    
    	类的定义格式:
    	public class 类名 {
    		
    	}
    	这是我定义的HelloWorld类
    */
    
    public class HelloWorld {
    	/*
    		这是main方法
    		main方法是程序的入口,代码的执行是从main方法开始的
    	*/
    	public static void main(String[] args) {
    		//这是输出语句,""里面的内容是可以改变的
    		System.out.println("Hello World");
    	}
    }
    

    关键字

    • 关键字的字母全部小写
    • 常用的代码编辑器,针对关键字有特殊的颜色标记,非常直观
    • Java的关键字有五十个左右

    常量

    常量:在程序运行中,其值不可以改变的的量

    常量类型说明举例
    字符串常量用双引号括起来的内容“HelloWold”,“黑马程序员”
    整数常量不带小数的数字666,-88
    小数常量带小数的数字13.14,-5.21
    字符常量用单引号括起来的内容‘A’,‘0’,‘我’
    布尔常量布尔值,表示真假只有两个值:true,false
    空常量一个特殊值,空值值是:null
    public class ConstantDemo {
    	public static void main(String[] args) {
    		//字符串常量
    		System.out.println("Hello,World");
    		System.out.println("黑马程序员");
    		System.out.println("-------");
    
    		//整数常量
    		System.out.println(666);
    		System.out.println(-88);
    		System.out.println("-------");
    
    		//小数常量
    		System.out.println(13.14);
    		System.out.println(-5.21);
    		System.out.println("--------");
    
    		//字符常量
    		System.out.println('A');
    		System.out.println('0');
    		System.out.println('我');
    		System.out.println("-------");
    
    		//布尔常量
    		System.out.println(true);
    		System.out.println(false);
    		System.out.println("-------");
    
    		//空常量
    		//空常量不能直接输出
    		//System.out.println(null);
    	}
    }
    
    D:\Java\mycode>javac ConstantDemo.java
    
    D:\Java\mycode>java ConstantDemo
    Hello,World
    黑马程序员
    -------
    666
    -88
    -------
    13.14
    -5.21
    --------
    A
    0
    我
    -------
    true
    false
    -------
    

    数据类型

    Java语言是强类型语言,对于每一种数据都给出了明确的数据类型,不同的数据类型也分配了不同的内存空间,所以它们表示的数据大小也是不一样的。

    在这里插入图片描述

    数据类型关键字内存占用取值范围
    整数byte1Byte-128~127
    整数short2Byte-32768~32767
    整数int(默认)4Byte-231~231-1
    整数long8Byte-263~263-1
    浮点数float4Byte负数:-3.402823E+38~-1.401298E-45
    正数:1.401298E-45~3.402823E+38
    浮点数double(默认)8Byte负数:-1.797693E+308-4.9000000E-324
    正数:4.9000000E-3241.797693E+308
    字符char2Byte0-65535
    布尔boolean1Bytetrue,false

    说明:E+38表示是乘以10的38次方,同样,E-45表示乘以10的负45次方

    标识符

    • 规则:由数字、字母、下划线(_)、美元符($)组成
    • 不能以数字开头
    • 不能是关键字
    • 区分大小写

    《标识符常见命名规定》

    小驼峰命名法:针对方法变量

    • 约定一:标识符是一个单词的时候,首字母小写

      例如:name

    • 约定二:标识符由多个单词组成的时候,第一个单词首写字母小写,其他单词首字母大写

      例如:firstName

    大驼峰命名法:针对

    • 约定一:标识符是一个单词的时候,首字母大写

      例如:Student

    • 约定二:标识符由多个单词组成的时候,每个单词首写字母大写

      例如:GoodStudent

    类型转换

    • 自动类型转换
      把一个表示数据范围小的数值或者变量赋值给另一个表示数据范围大的变量
      在这里插入图片描述
    • 强制类型转换
      把一个表示数据范围大的数值或者变量赋值给另一个表示数据的范围小的变量
      格式:目标数据类型 变量名 = (目标数据类型)值或者变量;
      例子:int k = (int)88.88;
    public class ConversionDemo {
    	public static void main(String[] args) {
    		//自动类型转换
    		double d = 10;
    		System.out.println(d);
    
    		//定义byte类型的变量
    		byte b = 10;
    		short s = b;
    		int i = b;
    		System.out.println(s);
    		System.out.println(i);
    
    		//这是不可以的,类型不兼容
    		//char c = b;
    
    		//强制类型转换
    		int k = (int)88.88;
    		System.out.println(k);
    	}
    }
    
    D:\Java\mycode>javac ConversionDemo.java
    
    D:\Java\mycode>java ConversionDemo
    10.0
    10
    10
    88
    

    运算符

    运算符:对常量或者变量进行操作的符号

    表达式:用运算符把常量或者变量连接起来符合Java语法的式子就可以称为表达式。

    不同的运算符连接的表达式体现的是不同类型的表达式

    举例说明:

    int a = 10;
    int b = 20;
    int c = a + b;
    

    + : 是运算符,并且是算术运算符

    a + b : 是表达式,由于+是算术运算符,所以这个表达式叫算术表达式

    public class OperatorDemo01 {
    	public static void main (String[] args) {
    		//定义两个变量
    		int a = 6;
    		int b = 4;
    
    		System.out.println(a + b);
    		System.out.println(a - b);
    		System.out.println(a * b);
    		System.out.println(a / b);
    		System.out.println(a % b);
    		//除法得到的商,取余得到的是余数
    
    		//整数相除只能得到整数,要想得到小数,必须有浮点数的参与
    		System.out.println(6.0 / 4);
    	}
    }
    
    D:\Java\mycode>javac OperatorDemo01.java
    
    D:\Java\mycode>java OperatorDemo01
    10
    2
    24
    1
    2
    1.5
    

    字符"+"操作

    拿字符在计算机底层对应的数值来进行计算的,即ASCII码

    • A -> 65:A-Z是连续的
    • a -> 97:a-z是连续的
    • 0 -> 48:0-9是连续的

    算术表达式中包含多个基本数据类型的值的时候,整个算术表达式的类型自动进行提升

    提升规则:

    • byte类型,short类型和char类型将被提升到int类型

    • 整个表达式的类型自动提升到表达式中最高等级操作数同样的类型

      等级顺序:byte->short->char->int->long->float->double

    public class OperatorDemo02 {
    	public static void main (String[] args) {
    		//定义两个变量
    		int i = 10;
    		char c = 'A';//'A'的值是65
    		c = 'a';//'a'的值是97
    		c = '0';
    		System.out.println(i + c);
    
    		//char ch = i + c;
    		//char类型会被自动提升为int类型
    		int j = i + c;
    		System.out.println(j);
    
    		//int k = 10 + 13.14;
    		double d = 10 + 13.14;
    		System.out.println(d);
    	}
    }
    
    D:\Java\mycode>javac OperatorDemo02.java
    
    D:\Java\mycode>java OperatorDemo02
    58
    58
    23.14
    

    字符串"+"操作

    • +操作中出现字符串时,这个+字符串连接符,而不是算术运算。

    • +操作中,如果出现了字符串,就是连接运算符,否则就是算术运算。当连续进行+操作时,从左到右逐个执行。

      public class OperatorDemo03 {
      	public static void main(String[] args) {
      		System.out.println("it" + "heima");
      		System.out.println("itheima" + 666);
      		System.out.println(666 + "itheima");
      		System.out.println("黑马" + 6 + 66);
      		System.out.println(1 + 99 + "年黑马");
      	}
      }
    
      D:\Java\mycode>javac OperatorDemo03.java
      
      D:\Java\mycode>java OperatorDemo03
      itheima
      itheima666
      666itheima
      黑马666
      100年黑马
    

    复制运算符

    符号作用说明
    =赋值a=10,将10赋值给变量a
    +=加后赋值a+=b,将a+b的值给a
    -=减后赋值a-=b,将a-b的值给a
    *=乘后赋值a*=b,将a*b的值给a
    /=除后赋值a/=b,将a/b的商给a
    %=取余后赋值a%=b,将a%b的余数给a

    注意:扩展的赋值运算符隐含了强制类型转换

    自增自减运算符

    符号作用说明
    ++自增变量的值加1
    --自减变量的值减1

    注意事项:

    • ++--既可以放在变量后边,也可以放在变量的前边

    • 单独使用的时候,++--无论是放在变量前边还是后边,结果都是一样的。

    • 参与操作的时候,如果放在变量的后边,先拿变量参与操作,后拿变量做++或者--

      参与操作的时候,如果放在变量的前边,先拿变量做++或者--,后拿变量参与操作。

    • 最常见的用法:单独使用

    关系运算符

    符号说明
    ==a==b,判断a和b的值是否相等,成立为true,不成立为false
    !=a!=b,判断a和b的值是否不相等,成立为true,不成立为false
    >a>b,判断a是否大于b,成立为true,不成立false
    >=a>=b,判断a是否大于等于b,成立为true,不成立为false
    <a<b,判断a是否小于b,成立为true,不成立为false
    <=a<=b,判断a是否小于等于b,成立为true,不成立为false

    注意事项:关系运算符的结果都是boolean类型,要么是true,要么是false。

    逻辑运算符

    符号作用说明
    &逻辑与a&b,a和b都是true,结果为true,否则为false
    |逻辑或a|b,a和b都是false,结果为false,否则为true
    ^逻辑异或a^b,a和b的结果不同为true,相同为false
    !逻辑非!a,结果和a的结果正好相反

    短路逻辑运算符

    符号作用说明
    &&短路与作用和&相同,但是有短路效果
    ||短路或作用和|相同,但是有短路效果

    注意事项:

    • 逻辑与&,无论左边真假,右边都要执行。
      短路与&&,如果左边为真,右边执行,如果左边为假,右边不执行
    • 逻辑或|,无论左边真假,右边都要执行。
      短路或||,如果左边为假,右边执行;如果左边为真,右边不执行

    最常用的逻辑运算符:&&||!

    三元运算符

    格式:关系表达式?表达式1:表达式2;
    范例:a > b ? a : b;
    
    计算规则:
        首先计算关系表达式的值
        如果值为true,表达式1的值就是运算结果
        如果值为false,表达式2的值就是运算结果
    
    public class OperatorDemo {
    	public static void main(String[] args) {
    		//定义两个变量
    		int a = 10;
    		int b = 20;
    
    		//获取两个数值当中的较大值
    		int max = a > b ? a : b;
    		System.out.println("max: " + max);
    	}
    }
    
    D:\Java\mycode>javac OperatorDemo.java
    
    D:\Java\mycode>java OperatorDemo
    max: 20
    

    案例:两只老虎

    public class OperatorDemo {
    	public static void main(String[] args) {
    		int weight1 = 180;
    		int weight2 = 200;
    
    		boolean b = weight1 == weight2 ? true : false;
    
    		System.out.println("b:" + b);
    	}
    }
    
    D:\Java\mycode>javac OperatorDemo.java
    
    D:\Java\mycode>java OperatorDemo
    b:false
    

    案例:三个和尚

    public class OperatorDemo {
    	public static void main(String[] args) {
    		int height1 = 155;
    		int height2 = 165;
    		int height3 = 210;
    
    		int tempHeight = height1 > height2 ? height1 : height2;
    		int maxHeight = tempHeight > height3 ? tempHeight : height3;
    
    		System.out.println("Max Height: " + maxHeight); 
    	}
    }
    
    D:\Java\mycode>javac OperatorDemo.java
    
    D:\Java\mycode>java OperatorDemo
    Max Height: 210
    

    数据输入

    1. 导包

      import java.util.Scanner;
      
    2. 创建对象

      Scanner sc = new Scanner(System.in);
      

      sc为变量名

    3. 接收数据

      int i = sc.nextInt();
      
       import java.util.Scanner;
       
       public class ScannerDemo {
       	public static void main(String[] args) {
       		Scanner sc = new Scanner(System.in);
       		int x = sc.nextInt();
       		System.out.println("x: " + x);
       	}
       }
    
       D:\Java\mycode>javac ScannerDemo.java
       
       D:\Java\mycode>java ScannerDemo
       77
       x: 77
    

    案例:三个和尚升级版

    import java.util.Scanner;
    
    public class ScannerTest {
    	public static void main(String[] args) {
    		Scanner sc = new Scanner(System.in);
    		
    		System.out.println("请输入第一个和尚的身高:");
    		int height1 = sc.nextInt();
    
    		System.out.println("请输入第二个和尚的身高:");
    		int height2 = sc.nextInt();
    
    		System.out.println("请输入第三个和尚的身高:");
    		int height3 = sc.nextInt();
    
    		int tempHeight = height1 > height2 ? height1 : height2;
    		int maxHeight = tempHeight > height3 ? tempHeight : height3;
    		
    		System.out.println("这三个和尚中身高最高的是:" + maxHeight + "cm");
    
    	}
    }
    
    D:\Java\mycode>javac ScannerTest.java
    
    D:\Java\mycode>java ScannerTest
    请输入第一个和尚的身高:
    177
    请输入第二个和尚的身高:
    189
    请输入第三个和尚的身高:
    176
    这三个和尚中身高最高的是:189cm
    

    if…else语句

    public class IfDemo {
    	public static void main(String[] args) {
    		System.out.println("开始");
    		int a = 10;
    		int b = 20;
    		if(a == b) {
    			System.out.println("a等于b");
    		}
    		int c = 10;
    		if(a == c) {
    			System.out.println("a等于c");
    		}
    		System.out.println("结束");
    	}
    }
    
    D:\Java\mycode>javac IfDemo.java
    
    D:\Java\mycode>java IfDemo
    开始
    a等于c
    结束
    
    public class IfDemo {
    	public static void main(String[] args) {
    		System.out.println("开始");
    		int a = 10;
    		int b = 20;
    		if(a > b) {
    			System.out.println("a的值大于b");
    		}else {
    			System.out.println("a的值不大于b");
    		}
    		System.out.println("结束");
    	}
    }
    
    D:\Java\mycode>javac IfDemo.java
    
    D:\Java\mycode>java IfDemo
    开始
    a的值不大于b
    结束
    

    案例:判断奇偶数

    import java.util.Scanner;
    
    public class IfTest {
    	public static void main(String[] args) {
    		Scanner sc = new Scanner(System.in);
    		System.out.println("请输入一个数判断奇偶:");
    		int number = sc.nextInt();
    		if(number % 2 == 0) {
    			System.out.println(number + "是偶数");
    		}else {
    			System.out.println(number + "是奇数");
    		}
    
    	}
    }
    
    D:\Java\mycode>javac IfTest.java
    
    D:\Java\mycode>java IfTest
    请输入一个数判断奇偶:
    9
    9是奇数
    
    D:\Java\mycode>java IfTest
    请输入一个数判断奇偶:
    6
    6是偶数
    

    if…else…if结构

    import java.util.Scanner;
    
    public class IfDemo {
    	public static void main(String[] args) {
    		Scanner sc = new Scanner(System.in);
    		System.out.println("请输入一个星期数(1-7):");
    		int week = sc.nextInt();
    
    		if(week == 1) {
    			System.out.println("星期一");
    		}else if(week == 2) {
    			System.out.println("星期二");
    		}else if(week == 3) {
    			System.out.println("星期三");
    		}else if(week == 4) {
    			System.out.println("星期四");
    		}else if(week == 5) {
    			System.out.println("星期五");
    		}else if(week == 6) {
    			System.out.println("星期六");
    		}else {
    			System.out.println("星期天");
    		}
    	} 
    }
    
    D:\Java\mycode>javac IfDemo.java
    
    D:\Java\mycode>java IfDemo
    请输入一个星期数(1-7):
    7
    星期天
    
    D:\Java\mycode>java IfDemo
    请输入一个星期数(1-7):
    2
    星期二
    
    D:\Java\mycode>java IfDemo
    请输入一个星期数(1-7):
    5
    星期五
    

    案例:考试奖励

    import java.util.Scanner;
    
    public class IfTest {
    	public static void main(String[] args) {
    		Scanner sc = new Scanner(System.in);
    		System.out.println("请输入一个分数:");
    		int score = sc.nextInt();
    		if(score > 100 || score < 0) {
    			System.out.println("你输入的分数有误");
    		}else if(score >= 95 && score <= 100) {
    			System.out.println("山地自行车一辆");
    		}else if(score >= 90 && score <= 94) {
    			System.out.println("游乐场玩一次");
    		}else if(score >= 80 && score <= 89) {
    			System.out.println("变形金刚玩具一个");
    		}else {
    			System.out.println("胖揍一顿");
    		}
     	}
    }
    
    D:\Java\mycode>javac IfTest.java
    
    D:\Java\mycode>java IfTest
    请输入一个分数:
    102
    你输入的分数有误
    
    D:\Java\mycode>java IfTest
    请输入一个分数:
    100
    山地自行车一辆
    
    D:\Java\mycode>java IfTest
    请输入一个分数:
    92
    游乐场玩一次
    
    D:\Java\mycode>java IfTest
    请输入一个分数:
    85
    变形金刚玩具一个
    
    D:\Java\mycode>java IfTest
    请输入一个分数:
    67
    胖揍一顿
    

    switch语句

    switch(表达式) {
        case1:
            语句体1;
            break;
        case2:
            语句体2;
            break;
        ...
        default:
            语句体n+1;
            [break;]
            
    }
    

    格式说明:

    • 表达式:取值为byteshortintchar,JDK5以后可以是枚举,JDK7以后可以是String。
    • case:后面跟的是要和表达式进行比较的值
    • break:表示中断,结束的意思,用来结束switch语句
    • default:表示所有情况都不匹配的时候,就执行该处的内容,和if语句的else相似。

    执行流程:

    1. 首先计算表达式的值。

    2. 依次和case后面的值进行比较,如果有对应的值,就会执行相应的语句,在执行过程中,遇到break就会结束。

    3. 如果所有的case后面的值和表达式的值都不匹配,就会执行default里面的语句体,然后程序结束掉。

    import java.util.Scanner;
    
    public class SwitchDemo {
    	public static void main(String[] args) {
    		System.out.println("开始");
    		Scanner sc = new Scanner(System.in);
    		System.out.println("请输入一个星期数(1-7):");
    		int week = sc.nextInt();
    
    		switch(week) {
    		case 1:
    			System.out.println("星期一");
    			break;
    		case 2:
    			System.out.println("星期二");
    			break;
    		case 3:
    			System.out.println("星期三");
    			break;
    		case 4:
    			System.out.println("星期四");
    			break;
    		case 5:
    			System.out.println("星期五");
    			break;
    		case 6:
    			System.out.println("星期六");
    			break;
    		case 7:
    			System.out.println("星期天");
    			break;
    		default:
    			System.out.println("你输入的星期数有误");
    			break;
    		}
    		System.out.println("结束");
    	}
    }
    
    D:\Java\mycode>javac SwitchDemo.java
    
    D:\Java\mycode>java SwitchDemo
    开始
    请输入一个星期数(1-7):
    4
    星期四
    结束
    
    D:\Java\mycode>java SwitchDemo
    开始
    请输入一个星期数(1-7):
    9
    你输入的星期数有误
    结束
    
    D:\Java\mycode>java SwitchDemo
    开始
    请输入一个星期数(1-7):
    2
    星期二
    结束
    

    案例:春夏秋冬

    import java.util.Scanner;
    
    public class SwitchTest {
    	public static void main(String[] args) {
    		Scanner sc = new Scanner(System.in);
    		System.out.println("请输入月份(1-12):");
    		int month = sc.nextInt();
    
    		switch(month) {
    		case 1:
    		case 2:
    		case 12:
    			System.out.println("冬季");
    			break;
    		case 3:
    		case 4:
    		case 5:
    			System.out.println("春季");
    			break;
    		case 6:
    		case 7:
    		case 8:
    			System.out.println("夏季");
    			break;
    		case 9:
    		case 10:
    		case 11:
    			System.out.println("秋季");
    			break;
    		default:
    			System.out.println("你输入的月份有误");
    		}
    
    	}
    }
    

    注意事项:在switch语句中,如果case控制的语句体后面不写break,将出现穿透现象,在不判断下一个case值得情况下,向下运行,直到遇到break,或者整体switch语句结束

    for循环语句

    格式:

    for(初始化语句;条件判断语句;条件控制语句;) {
        循环体语句;
    }
    

    在这里插入图片描述

    public class ForDemo {
    	public static void main(String[] args) {
    		for(int i=1;i<=5;i++) {
    			System.out.println("Hello,World");
    		}
    	}
    }
    
    D:\Java\mycode>javac ForDemo.java
    
    D:\Java\mycode>java ForDemo
    Hello,World
    Hello,World
    Hello,World
    Hello,World
    Hello,World
    

    案例:输出数据

    public class ForTest {
    	public static void main(String[] args) {
    		for(int i=1; i<=5; i++) {
    			System.out.println(i);
    		}
    		System.out.println("--------");
    		for(int j=5; j>=1; j--) {
    			System.out.println(j);
    		}
    	}
    }
    
    D:\Java\mycode>javac ForTest.java
    
    D:\Java\mycode>java ForTest
    1
    2
    3
    4
    5
    --------
    5
    4
    3
    2
    1
    

    案例:求和

    public class ForTest {
    	public static void main(String[] args) {
    		int sum = 0;
    		for(int i=1; i<=5; i++) {
    			sum += i;
    		}
    		System.out.println("1-5之间的数据和是:" + sum);
    	}
    }
    
    D:\Java\mycode>javac ForTest.java
    
    D:\Java\mycode>java ForTest
    1-5之间的数据和是:15
    

    案例:求偶数和

    public class ForTest {
    	public static void main(String[] args) {
    		int sum = 0;
    		for(int i=1; i<=100; i++) {
    			if(i%2 == 0) {
    				sum += i;
    			}
    		}
    		System.out.println("1-100之间的偶数和:" + sum);
    	}
    }
    
    D:\Java\mycode>javac ForTest.java
    
    D:\Java\mycode>java ForTest
    1-100之间的偶数和:2550
    

    案例:水仙花数

    • 水仙花数是一个三位数
    • 水仙花数的个位、十位、百位的数字立方和等于原数
    public class ForTest {
    	public static void main(String[] args) {
    		for(int i=100; i<1000; i++) {
    			//在计算之前获取三位数中每个位上的值
    			int ge = i % 10;
    			int shi = i / 10 % 10;
    			int bai = i / 10 / 10 % 10;
    			//判定条件是将三位中数的每个数值取出来,计算立方和后与原始数字比较是否相等
    			if(ge*ge*ge + shi*shi*shi + bai*bai*bai == i) {
    				//输出满足条件的数字就是水仙花数
    				System.out.println(i);
    			}
    		}
    	}
    }
    
    D:\Java\mycode>javac ForTest.java
    
    D:\Java\mycode>java ForTest
    153
    370
    371
    407
    

    案例:统计

    public class ForTest {
    	public static void main(String[] args) {
    		int count = 0;
    		for(int i=100; i<1000; i++) {
    			int ge = i % 10;
    			int shi = i / 10 % 10;
    			int bai = i / 10 / 10 % 10;
    			if(ge*ge*ge + shi*shi*shi + bai*bai*bai == i) {
    				count++;
    			}
    		}
    		System.out.println("水仙花数共有" + count + "个");
    	}
    }
    
    D:\Java\mycode>javac ForTest.java
    
    D:\Java\mycode>java ForTest
    水仙花数共有4个
    

    While循环语句

    初始化语句;
    while(条件判断语句) {
        循环体语句;
        条件控制语句;
    }
    

    在这里插入图片描述

    public class WhileDemo {
    	public static void main(String[] args) {
    		int i = 1;
    		while(i <= 5) {
    			System.out.println(i);
    			i++;
    		}
    	}
    }
    

    案例:珠穆朗玛峰

    public class WhileTest {
    	public static void main(String[] args) {
    		int count = 0;
    		double paper = 0.1;
    		int zf = 8844430;
    		while(paper <= zf) {
    			paper *= 2;
    			count++;
    		}
    		System.out.println("需要折叠: " + count + "次");
    	}
    }
    
    D:\Java\mycode>javac WhileTest.java
    
    D:\Java\mycode>java WhileTest
    需要折叠: 27次
    

    do…while语句

    初始化语句;
    do {
        循环体语句;
        条件控制语句;
    }while(条件判断语句);
    
    public class DoWhileDemo {
    	public static void main(String[] args) {
    		int i = 1;
    		do {
    			System.out.println("Hello,World");
    			i++;
    		}while(i<=5);
    	}
    }
    
    D:\Java\mycode>javac DoWhileDemo.java
    
    D:\Java\mycode>java DoWhileDemo
    Hello,World
    Hello,World
    Hello,World
    Hello,World
    Hello,World
    

    跳转控制语句

    • continue:用于在循环中,基于条件控制,跳过某次循环内容的执行,继续下一次的执行
    • break:用于在循环中,基于条件控制,终止循环内容的执行,也就是说结束当前整个循环

    循环嵌套

    public class ForForDemo {
    	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 + "分");
    			}
    			System.out.println("-------");
    		}
    	}
    }
    

    随机数Random

    • 导包

      import java.util.Random
      
    • 创建对象

      Random r = new Random();
      

      r是变量名

    • 获取随机数

      int number = r.nextInt();//获取数据的范围:[0,10),包括0,不包括10
      
    import java.util.Random;
    
    public class RandomDemo {
    	public static void main(String[] args) {
    		Random r = new Random();
    		for(int i=0; i<10; i++) {
    			int number = r.nextInt(10);
    			System.out.println("number: " + number);
    		}
    
    		//获取一个1-100之间的随机数
    		int x = r.nextInt(100) + 1;
    		System.out.println("1~100之间的随机数:" + x);
    	}
    }
    
    D:\Java\mycode>javac RandomDemo.java
    
    D:\Java\mycode>java RandomDemo
    number: 7
    number: 6
    number: 8
    number: 1
    number: 9
    number: 9
    number: 1
    number: 7
    number: 4
    number: 5
    1~100之间的随机数:61
    

    案例:猜数字

    import java.util.Scanner;
    import java.util.Random;
    
    public class RandomTest {
    	public static void main(String[] args) {
    		Random r = new Random();
    		Scanner sc = new Scanner(System.in);
    		System.out.println("《猜数字游戏》");
    		int number = r.nextInt(100) + 1;
    		while(true) {
    			System.out.println("请输入你猜的数字(1~100):");
    			int guessNumber = sc.nextInt();
    			if(number > guessNumber) {
    				System.out.println("你猜的数字小了");
    			}else if(number < guessNumber) {
    				System.out.println("你猜的数字大了");
    			}else {
    				System.out.println("恭喜你猜对了!");
    				break;
    			}
    		}
    	}
    }
    
    D:\Java\mycode>javac RandomTest.java
    
    D:\Java\mycode>java RandomTest
    《猜数字游戏》
    请输入你猜的数字(1~100):
    50
    你猜的数字小了
    请输入你猜的数字(1~100):
    75
    你猜的数字小了
    请输入你猜的数字(1~100):
    83
    你猜的数字大了
    请输入你猜的数字(1~100):
    80
    你猜的数字大了
    请输入你猜的数字(1~100):
    77
    你猜的数字大了
    请输入你猜的数字(1~100):
    76
    恭喜你猜对了!
    
    展开全文
  • 黑马java se视频笔记

    2017-11-01 13:29:53
    黑马JAVASE课程笔记完整版pdf,MD版本生成的pdf,自制
  • 2018年黑马程序员全套教程java基础第1天 jdk9教程,idea的使用等,java小白的最优之教程
  • 黑马课程Java学习笔记(1. Java概述)1. Java概述1.1 Java语言发展史1.2 Java语言跨平台原理1.3 JRE和JDK1.4 JDK的下载和安装 1. Java概述 1.1 Java语言发展史 Java语言是美国Sun公司(Stanford University Network...

    黑马程序员Java课程学习笔记

    1. Java概述

    1.1 Java语言发展史

    Java语言是美国Sun公司(Stanford University Network)在1995年推出的计算机语言, 2009年Oracle甲骨文公司收购Sun公司。Java之父:詹姆斯·高斯林(James Gosling)。

    1.2 Java语言跨平台原理

    Java可以在任意操作系统上运行,Windows、Mac、Linux。我们只需要在运行Java应用程序的操作系统上,安装一个与操作系统对应的Java虚拟机(JVM Java Virtual Machine)就可以实现Java的跨平台使用了。

    1.3 JRE和JDK

    (1)JRE(Java Runtime Environment) 是Java程序的运行时环境,它包括JVM和运行时所需要的核心类库。需要注意的是,JRE是包含JVM的,因此只安装JRE也是可以实现Java的跨平台使用的。
    (2)JDK(Java Development Kit) 是Java程序的开发工具包,包含JRE和开发人员使用的工具。其中的开发工具包括:编译工具(javac.exe)和运行工具(java.exe)。如果想开发一个全新的Java程序,必须安装JDK。
    (3)JDK、JRE和JVM的关系 由下图我们可以看出,JDK包含JRE,JRE包含JVM。对于开发人员来说,我们只需要使用JDK就可以满足一切开发和应用的需求。
    JDK、JRE和JVM的关系

    1.4 JDK和Eclipse的下载和安装

    (1)在这里,我引用了另一位博主的安装教程eclipse安装教程(2021最新版)超级易懂到吐血
    (2)JDK的安装目录及说明:**
    在这里插入图片描述

    2. 基础语法

    2.1 注释

    (1)什么是注释:注释是在程序指定位置添加的说明性信息。注释不参与程序运行,仅起到说明作用。

    (2)注释的分类

    注释类别格式
    单行注释// 注释信息
    多行注释/* 注释信息 */
    文档注释/** 注释信息 */

    (3)示例

    /*
    	Java程序中最基本的组成单位是类。
    	类的定义格式:
    		public class 类名{
    		
    		}
    	这是定义的HelloWorld类
    */
    public class HelloWorld{
    	/*
    		这是main方法
    		main方法是程序的入口,代码的执行是从main方法开始的
    	*/
    	public static void main(String[] args) {
    		// 这是输出语句,“”里面的内容是可以改变的
    		System.out.println("HelloWorld");
    	}
    }
    

    2.2 关键字

    (1)概念:关键字是被Java赋予了特定含义的单词。
    (2)特点
        *关键字的字母全部小写;
        *常用的代码编辑器,针对关键字有特殊的颜色标记,非常直观

    2.3 常量

    (1)概念:在程序运行过程中,其值不可以发生改变的量。
    (2)常量分类
    在这里插入图片描述

    2.4 数据类型

    (1)计算机存储单元:计算机存储设备的最小信息单元是“位(bit)”,又称为比特位,常用小写字母“b”表示。计算机中最小的存储单元是“字节(byte)”,通常用大写字母“B”表示,字节是由连续的8个位组成。其他常用的存储单位如下:
        1B = 8bit;
        1KB = 1024B;
        1MB = 1024KB;
        1GB = 1024MB;
        1TB = 1024GB
    (2)数据类型:Java语言是强类型语言,对于每一种数据都给出了明确的数据类型,不同的数据类型也分配了不同的内存空间,所有它们表示的数据大小也是不一样的。
    在这里插入图片描述
    (3)数据类型内存占用和取值范围
    在这里插入图片描述

    2.5 变量

    (1)概念:变量是在程序运行过程中,其值可以改变的量。从本质上讲,变量是内存中一小块区域。
    (2)变量定义:数据类型 变量名 = 变量值; 例如,int a = 10;
    (3)变量的使用:包括取值和修改值。

    public class VariableDemo{
    	public static void main(String[] args){
    		//定义变量
    		int a = 10;
    
    		//输出变量
    		System.out.println(a);
    
    		//修改变量
    		a = 20;
    		System.out.println(a);
    }
    }
    

    (4)变量使用的注意事项
        *变量名称不能重复;
        *变量必须先赋值再使用;
        *long类型变量定义的时候,为了防止整数过大,后面要加L;
        *float类型变量定义的时候,为了防止类型不兼容,后面要加F。

    2.6 标识符

    (1)概念:标识符是给类、方法、变量等起名字的符号。

    (2)标识符定义规则
        *由数字、字母、下划线和美元符组成;
        *不能以数字开头;
        *不能是关键字;
        *要区分大小写

    (3)常见命名约定
      *小骆峰命名法:方法、变量
         **约定1:标识符是一个单词的时候,首字母小写;
         **约定2:标识符由多个单词组成的时候,第一个单词首字母小写,其他单词首字母大写;

      *大骆峰命名法:类
         **约定1:标识符是一个单词的时候,首字母大写;
         **约定2:标识符由多个单词组成的时候,每个单词的首字母大写;

    2.7 类型转换

    (1)类型转换分类:自动类型转换;强制类型转换

    (2)自动类型转换:把一个表示数据范围小的数值或者变量赋值给另一个表示数据范围大的变量。
    例如:double d = 10;
    在这里插入图片描述
    (3)强制类型转换:把一个表示数据范围大的数值或者变量赋值给另一个表示数据范围小的变量。
    例如:int k = (int)88.88

    3. 运算符

    3.1 算数运算符

    3.1.1 运算符

    运算符是对常量或者变量进行操作的符号。

    3.1.2 表达式

    用运算符把常量或者变量连接起来符合java语法的式子即为表达式。不同运算符连接的表达式体现的是不同类型的表达式。
       例如:int a =10; int b = 20; int c = a + b;
       +:是运算符,并且是算术运算符;a + b:是表达式,由于+是算术运算符,所以这个表达式称为算术表达式。

    示例

    /*
    	算术运算符
    */
    public class OperatorDemo1{
    	public static void main(String[] args){
    		//定义两个变量
    		int a = 6;
    		int b = 4;
    
    		System.out.println(a + b);			# out>>10
    		System.out.println(a - b);			# out>>2
    		System.out.println(a * b);			# out>>24
    		System.out.println(a / b);			# out>>1
    		System.out.println(a % b);			# out>>2
    		//除法得到的是商,取余得到的是余数
    
    		//整数相除只能得到整数,要想得到小数,必须有浮点数的参与
    		System.out.println(6.0 / 4);	 	# out>>1.5
    }
    }
    

    3.1.3 字符的 ‘+’ 操作

    字符的 ‘+’ 操作是字符在计算机底层对应的数值来进行计算的。
    在这里插入图片描述
    算术表达式中包含多个基本数据类型的值的时候,整个算术表达式的类型会自动进行提升。

    提升规则
      *byte类型,short类型和char类型将被提升到int类型;
      *整个表达式的类型自动提示到表达式中最高等级操作数同样的类型
      等级顺序:byte, short, char ->int->long->float->

    3.1.4 字符串的 ‘+’ 操作

    (1)当 ‘+’ 操作中出现字符串时,这个 ‘+’ 是字符串连接符,而不是算术运算;
    (2)在 ‘+’ 操作中,如果出现了字符串,就是连接运算符,否则就说算术运算。当连续进行 ‘+’ 操作时,从左到右逐个执行。

    示例

    /*
    字符串的 ‘+’ 操作
    */
    public class OperatorDemo03{
    	public static void main(String[] args){
    		System.out.println("it" + "heima");			# out>>itheima
    		System.out.println("itheima" + "666");		# out>>itheima666
    		System.out.println("666" + "itheima");		# out>>666itheima
    
    		System.out.println("黑马" + 6 + 66);		# out>>黑马666
    		System.out.println(1 + 99 + "年黑马");		# out>>100年黑马
    	}
    }
    

    3.2 赋值运算符

    在这里插入图片描述

    3.3 自增自减运算符

    在这里插入图片描述

    3.4 关系运算符

    在这里插入图片描述

    3.5 逻辑运算符

    概念:逻辑运算符是用来连接关系表达式的运算符,也可以直接连接布尔类型的常量或变量。
    在这里插入图片描述

    3.6 短路运算符

    在这里插入图片描述
    注意
    (1)逻辑与&,无论左边真假,右边都要执行。
    (2)短路与&&,如果左边为真,右边执行;如果左边为假,右边不执行。
    (3)逻辑或|,无论左边真假,右边都要执行。
    (4)短路或|,如果左边为假,右边执行;如果左边为真,右边不执行。

    3.7 三元运算符

    格式:关系表达式?表达式1:表达式2

    计算规则:首先计算关系表达式的值,如果值为true,表达式1的值就是运算结果;如果值为false,表达式2的值就是运算结果。

    示例

    /*
    	三元运算符
    */
    public class OperatorDemo{
    	public static void main(String[] args){
    	//定义两个变量
    	int a = 10;
    	int b = 20;
    	
    	//获取两个数据中的较大值
    	int max = a > b ? a : b;
    	
    	//输出结果
    	System.out.println("max:" + max);			# out>>max:20
    	}
    }
    

    4. 数据输入

    Scanner使用的基本步骤
    (1)导包:import java.util.Scanner;           导包的动作必须出现在类定义的上边
    (2)创建对象:Scanner sc = new Scanner(System.in);   这里面只有sc是变量名,可以改变。其他的都不能变
    (3)接收数据:int i = sc.nextInt();             上面这个格式,只有i是变量名,可以变,其他都不能变
    (4)示例

    /*
    	数据输入:
    		(1)导包:
    				import java.util.Scanner;
    		(2)创建对象:
    				Scanner sc = new Scanner(System.in);
    		(3)接收数据:
    				int x = sc.nextInn();
    */
    import java.util.Scanner;
    
    public class ScannerDemo{
    	public static void main(String[] args){
    	//创建对象
    	Scanner sc = new Scanner(System.in);
    
    	//接收数据
    	int x = sc.nextInt();
    
    	//输出数据
    	System.out.println("x:" + x);
    	}
    }
    

    5. 分支语句

    5.1 流程控制

    流程控制语句分类:(1)顺序结构;(2)分支结构(if, switch);(3)循环结构(for, while, do…while)

    5.2 顺序结构

    概念:顺序结构是程序中最简单、最基本的流程控制,没用特定的语法结构,按照代码的先后顺序,依次执行,程序中大多数的代码都是这样执行的。

    5.3 if语句

    (1)格式1

    if (关系表达式){
    	语句体;
    }
    

    执行流程
    首先计算关系表达式的值;
    如果关系表达式的值为true,则执行语句体;
    如果关系表达式的值为false就不执行语句体;
    继续执行后面的语句内容。

    (2)格式2

    if (关系表达式){
    	语句体1}else{
    	语句体2}
    

    执行流程
    首先计算关系表达式的值;
    如果关系表达式的值为true,则执行语句体1;
    如果关系表达式的值为false,则执行语句体2;
    继续执行后面的语句内容。

    (3)格式3

    if (关系表达式1){
    	语句体1;
    }else if(关系表达式2){
    	语句体2;
    }
    ···
    else{
    	语句体n+1;
    }
    

    执行流程
    (1)首先计算关系表达式的值;
    (2)如果关系表达式的值为true,则执行语句体1;
    (3)如果关系表达式的值为false,则执行语句体2;
    (4)继续执行后面的语句内容。

    5.4 switch语句

    格式

    switch(表达式){
    case1:
    			语句体1;
    			break;
    case2:
    			语句体2break;
    ···
    default:
    			语句体n+1;
    			[break;]
    }
    

    格式说明
    (1)表达式:取值为byte, short, int, char, string.
    (2)case:后面跟的是要和表达式进行比较的值。
    (3)break:表示中断,结束的意思,用来结束switch语句。
    (4)default:表示所有情况都不匹配的时候,就执行该处的内容,和if语句的else相似。

    6. 循环语句

    6.1 for 循环语句

    格式

    for (初始化语句;条件判断语句;条件控制语句){
    	循环体语句;
    }
    

    执行流程
    (1)执行初始化语句;
    (2)执行条件判断语句,看其结果是true还是false,如果是false,循环结束,如果是true,继续执行;
    (3)执行循环体语句;
    (4)执行条件控制语句;
    (5)回到(2)继续。

    6.2 while 循环语句

    格式

    初始化语句;
    while (条件判断语句){
    	循环体语句;
    	条件控制语句;
    }
    

    执行流程
    (1)执行初始化语句;
    (2)执行条件判断语句,看其结果是true还是false,如果是false,循环结束,如果是true,继续执行;
    (3)执行循环体语句;
    (4)执行条件控制语句;
    (5)回到(2)继续。

    6.3 do…while 循环语句

    格式

    初始化语句;
    do{
    	循环体语句;
    	条件控制语句;
    }while(条件判断语句);
    

    执行流程
    (1)执行初始化语句;
    (2)执行循环体语句;
    (3)执行条件控制语句;
    (2)执行条件判断语句,看其结果是true还是false,如果是false,循环结束,如果是true,继续执行;
    (5)回到(2)继续。

    6.4 三种循环的区别

    三种循环的区别
    (1)for循环和while循环先判断条件是否成立,然后决定是否执行循环体(先判断后执行);
    (2)do…while循环先执行一次循环体,然后判断条件是否成立,是否继续执行循环体(先执行后判断)。

    for和while的区别
    (1)条件控制语句所控制的自增变量,因为归属for循环的语法结构中,在for循环结束后,就不能再次被访问了;
    (2)条件控制语句所控制的自增变量,对于while循环来说不归属其语法结构中,在while循环结束后,该变量还可以继续使用。

    死循环格式
    (1)for(; ; ){}
    (2)while(true){}
    (3)do{}while(true);

    6.5 Random

    作用: 产生一个随机数。

    使用步骤
    (1)导包:import java.util.Random;
    (2)创建对象:Random r = new Random();
    (3)获取随机数:int number = r.nextInt(10); //获取数据的范围:[0,10],包括0,不包括10

    示例

    /*
    	Random
    */
    import java.util.Random
    
    public class RandomDemo{
    	public static void main(String[] args){
    		//创建对象
    		Random r = new Random();
    	
    		//用循环获取10个随机数
    		for(int i=0; i<10; i++){
    			//获取随机数
    			int number = r.nextInt(10);
    			System.out.println("number:" + number);
    		
    		//需求:获取一个1-100之间的随机数
    		int x = r.nextInt(100) + 1;
    		System.out.println(x);
    		}
    	}
    }
    

    7. IDEA

    7.1 IDEA概述

    (1)IDEA概述:IDEA全称IntelliJ IDEA,是用于Java语言开发的集成环境,是业界公认的目前用于Java程序开发最好的工具。
    是可以把代码编写、编译、执行、调试等多种功能综合到一起的开发工具。
    (2)IDEA的下载和安装: 参考这篇博客:IDEA的下载和使用安装

    7.2 IDEA中HelloWorld

    步骤
    (1)创建一个空项目(JavaSE_Code)
    (2)创建一个新模块(idea_test)
    (3)在idea_test模块下的src下创建一个包(com.itheima)
    (4)在com.itheima包下新建一个类(Helloworld)
    (5)在Helloworld类中编写代码
    (6)在idea中执行程序

    7.3 IDEA中项目结构

    Project–>模块–>包–>类
    在这里插入图片描述

    7.4 IDEA中内容辅助键和快捷键

    (1)快速生成语句
    快速生成main()方法:psvm,回车
    快速生成输出语句:sout,回车

    (2)内容辅助键
    ctrl+alt+space,内容提示,代码补全等

    (3)快捷键
    注释:
      单行:选中代码,ctrl+/
      多行:选址代码,ctrl+shift+/

    格式化:
      ctrl+alt+L

    8. 数组

    8.1 数组定义格式

    概念:数组(array)是一种用于存储多个相同类型数据的存储模型

    数组的定义格式
    (1)格式1:数据类型[ ] 变量名,例如:int [ ] arr。定义了一个int类型的数组,数组名是arr。
    (2)格式2:数据类型 变量名[ ], 例如:int arr[ ]。定义了一个int类型的变量,变量名是arr数组。

    8.2 数组初始化之动态初始化

    初始化:就说为数组中的数组元素分配内存空间,并为每个数组元素赋值。

    数组初始化类型:动态初始化、静态初始化

    动态初始化:初始化时只指定数组长度,由系统为数组分配初始值。

    动态初始化格式:数据类型 [ ] 变量名 = new 数据类型[数组长度],例如:int [] arr = new int[3]

    示例

    public class ArrayDemo{
    	public static void main(String[] args){
    	int[] arr = new int[3]
    	/*
    	左边:
    		int:说明数组中的元素是int类型
    		[]:说明这是一个数组
    		arr:这是数组的名称
    	右边:
    		new:为数组申请内存空间
    		int:说明数组中的元素类型是int类型
    		[]:说明这是一个数组
    		3:数组长度,其实就说数组中的元素个数
    	}
    }
    

    8.3 数组元素访问

    数组变量访问方式:数组名

    数组内部保存数据的访问方式:数组名[索引]

    什么是索引:索引是数组中数据的编号方式,用于访问数组中的数据使用,数组名[索引]等同于变量名,是一种特殊的变量名。注意:索引是从0开始的、索引是连续的、索引逐一增加,每次加1。

    示例

    public class ArrayDemo{
    	public static void main(String[] args){
    	int[] arr = new int[3]
    	
    	//输出数组名
    	System.out.println(arr);		# out>> [i@880ec60 内存地址
    
    	//输出数组中的元素
    	System.out.println(arr[0]);		# out>> 0
    	System.out.println(arr[0]);		# out>> 0
    	System.out.println(arr[0]);		# out>> 0
    	}
    }
    

    8.4 Java中内存分配

    在这里插入图片描述

    8.5 数组初始化之静态初始化

    静态初始化:初始化时指定每个数组元素的初始值,由系统决定数组长度。

    格式1:数据类型 [ ] 变量名 = new 数据类型[ ] {数据1, 数据2, 数据3, …},例如:int [ ] arr = new int[ ] {1, 2, 3};

    格式2:数据类型 [ ] 变量名 = {数据1, 数据2, 数据3, …},例如:int [ ] arr = {1, 2, 3};

    8.6 数组操作的两个常见小问题

    (1)索引越界
    (2)空指针异常

    8.7 数组常见操作

    ** 遍历**:for循环 + 数组名.length

    示例

    public class ArrayTest01{
    	public static void main(String[] args){
    		//定义数组
    		int[] arr = {1 , 2, 3, 4, 5};
    		
    		//使用通用的遍历格式
    		for(int x=0; x<arr.length; x++){
    			System.out.println(arr[x]);
    		}
    	}
    }
    

    9. 方法

    9.1 方法概述

    概念:方法(Method)是将具有独立功能的代码块组织成为一个整体,使其具有特殊功能的代码集。
    注意
    (1)方法必须先创建才可以使用,该过程称为方法定义;
    (2)方法创建后并不是直接运行的,需要手动使用后才执行,该过程称为方法调用。

    9.2 方法的定义和调用

    方法定义与调用

    // 方法定义
    public static void method_name(){
    	//方法体
    }
    
    //方法调用
    method_name()
    

    示例

    public class MethodDemo
    {
    	public static void main(String[] args)
    	{
    		//调用方法
    		isEvenNumber();
    	}
    	
    	//需求:定义一个方法,在方法中定义一个变量,判断该数据是否是偶数
    	public static void isEvenNumber()
    	{
    		//定义变量
    		int number = 10;
    		number = 9;
    		
    		//判断该数是否是偶数
    		if(number%2 ==0)
    		{
    			System.out.println(true);	
    		}
    		else
    		{
    			Systm.println(false);
    		}
    	}
    }
    

    9.3 带参数方法的定义和调用

    带参数方法定义

    1)格式: public static void 方法名(参数){... ...}2)格式(单个参数):public static void 方法名(数据类型 变量名){... ...}3)格式(多个参数):public static void 方法名(数据类型 变量名1, 数据类型 变量名2, ......{... ...}
    
    注意
    (1)方法定义时,参数中的数据类型与变量名都不能缺少,缺少任意一个程序将报错;
    (2)方法定义时,多个参数之间使用逗号分隔。
    

    带参数方法调用

    1)格式:方法名(参数);
    (2)格式(单个参数):方法名(变量名/常量值);
    (3)格式(多个参数):方法名(变量名1/常量值1, 变量名2/常量值2);
    
    注意:
    (1)方法调用时,参数的数量与类型必须与方法定义中的设置相匹配,否则程序将报错。
    

    形参和实参

    形参:方法定义中的参数,等同于变量定义格式;
    实参:方法调用中的参数,等同于使用变量或常量

    9.3 方法的注意事项

    (1)方法不能嵌套定义
    (2)void表示无返回值,可以省略return,也可以单独书写return,后面不加数据。

    (3)方法的通用格式:

    public static 返回值类型 方法名(参数)
    {
    	方法体;
    	return 数据;
    }
    其中:
    public static----修饰符,目前先记住这个格式
    返回值类型--------方法操作完毕之后返回的数据的数据类型
    方法名------------调用方法的时候使用的标识
    参数--------------由数据类型和变量名组成,多个参数之间使用逗号隔开
    方法体------------完成功能的代码块
    return-----------如果方法操作完毕,有数据返回,用于把数据返回给调用者
    
    

    (4)定义方法时需要注意:

    明确返回值类型:主要是明确方法操作完毕之后是否有数据返回,如果没用,写void;如果有,写对应的数据类型;
    明确参数:主要是明确参数的类型和数量

    (5)调用方法时需要注意:

    void类型的方法可以直接调用;
    非void类型的方法,推荐用变量接收调用;

    9.4 方法重载

    方法重载概念:方法重载指同一个类中定义的多个方法之间的关系,满足下列条件的多个方法相互构成重载:
    (1)多个方法在同一个类中;
    (2)多个方法具有相同的方法名;
    (3)多个方法的参数不相同,类型不同或者数量不同。

    方法重载特点
    (1)重载仅对应方法的定义,与方法的调用无关,调用方式参照标准格式;
    (2)重载仅针对同一个类中方法的名称与参数进行识别,与返回值无关,换句话说不能通过返回值来判断两个方法是否相互构成重载。

    示例;

    /*
    	方法重载:
    		多个方法在同一个类中;
    		多个方法具有相同的方法名;
    		多个方法的参数不相同,类型不同或者数量不同
    
    		与返回值无关,在调用方法的时候,Java虚拟机会通过参数的不同来区分同名的方法
    */
    public class MethoDemo
    {
    	public static void main(String[] args)
    	{
    		//调用方法
    		int result = sum(a:10, b:20);
    		System.out.println(result);
    		
    		double result2 = sum(a:10.0, b:20.0);
    		System.out.println(result2);
    
    		int reslult3 = sum(a:10, b:20, c:30);
    		System.out.println(result3);
    		
    	//需求1:求两个int类型数据和的方法
    	public static int sum(int a, int b)
    	{
    		return a + b;
    	}
    
    	//需求2:求两个double类型数据和的方法
    	public static int sum(double a, double b)
    	{
    		return a + b;
    	}
    
    	//需求3:求三个int类型数据和的方法
    	public static int sum(int a, int b, int c)
    	{
    		return a + b + c;
    	}
    }
    

    9.5 方法的参数的传递

    (1)对于基本数据类型的参数,形参的改变,不影响实际参数的值。
    在这里插入图片描述
    (2)对于引用类型的参数,形参的改变,影响实际参数的值。
    在这里插入图片描述



    10 面向对象基础

    10.1 类和对象

    1. 什么是对象:万物皆对象,客观存在的事物皆为对象。
    2. 什么是对象的属性: 对象具有的各种特征,每个对象的每个属性都拥有特定的值。
    3. 什么是对象的行为: 对象能够执行的操作。

    4. 什么是类:类是对现实生活中一类具有共同属性和行为的事物的抽象,确定对象将会拥有的属性和行为。类是JAVA程序的基本组成单位。
      类的特点:
      (1)类是对象的数据类型;
      (2)类是具有相同属性和行为的一组对象的集合。
    5. 类和对象的关系:类是对象的抽象,对象是类的实体。

    6. 类的组成:属性和行为。
      属性:在类中通过成员变量来体现(类中方法外的变量)
      行为:在类中通过成员方法来体现(和前面的方法相比去掉static关键字即可)

    7. 类的定义

    public calss 类名{
    	// 成员变量
    	变量1的数据类型 变量1;
    	变量2的数据类型 变量2;
    	...
    	//成员方法
    	方法1;
    	方法2;
    	...
    }
    

    8. 对象的使用:
      (1)创建对象:类名 对象名 = new 类名();
      (2)使用对象:使用成员变量:对象名.变量名;使用成员方法:对象名.方法名()

    10.2 成员变量和局部变量

    1. 成员变量:类中方法外的变量。
    2. 局部变量:类中方法中的变量。

    public class Student{
    	String name;					// 成员变量
    
    	public void study(){
    		int i = 0;					// 局部变量
    		System.out.println('Good good study!');
    	}
    
    	int age;						// 成员变量
    }
    

    3. 成员变量和局部变量的区别

    在这里插入图片描述

    10.3 封装

    10.3.1 private关键字

    作用:private是一个关键字;它可以修饰成员(成员变量和成员方法);作用是保护成员不被别的类使用,被private修饰的成员只能在本类中才能访问。
    使用:针对private修饰的成员变量,如果需要被其他类使用,应提供相应的操作。
    (1)提供 get变量名() 方法,用于获取成员变量的值,方法用public修饰;
    (2)提供 set变量名(参数)方法,用于设置成员变量的值,方法用public修饰。

    public class Student{
    	//成员变量
    	String name;
    	private int age;
    
    	//提供get/set方法
    	public void setAge(int a){
    		if (a<0 || a>120){
    			System.out.println("你给的年龄有误");
    		}else{
    			age = a;
    		}
    	}
    	
    	public int getAge(){
    		return age;
    	}
    
    }
    

    10.3.2 this关键字

    (1)this修饰的变量用于指代成员变量。
        方法的形参如果与成员变量同名,不带this修饰的变量指的是形参,而不是成员变量;
        方法的形参没用与成员变量同名,不带this修饰的变量指的是成员变量。
    (2)this代表所在类的对象引用。方法被哪个对象调用,this就代表哪个对象。


    10.3.3 封装

    1. 封装概述:封装是面向对象三大特征之一(封装、继承、多态),是面向对象编程语言对客观世界的模拟,客观世界里成员变量都是隐藏在对象内部的,外界是无法直接操作的。
    2. 封装原则:将类的某些信息隐藏在类内部,不允许外部程序直接访问,而是通过该类提供的方法来实现对隐藏信息的操作和访问成员变量private,提供对应的getXxx() / setXxx()方法。
    3. 封装优点:通过方法来控制成员变量的操作,提高了代码的安全性。把代码用方法进行封装,提高了代码的复用性。


    10.3.4 构造方法

    概念:构造方法是一种特殊的方法,用于创建对象,功能是完成对数据的初始化。
    格式

    public class 类名{
    	修饰符 类名(参数){
    	}
    }
    

    注意事项
    (1)构造方法的创建:如果没有定义构造方法,系统将给出一个默认的无参数构造方法;如果定义了构造方法,系统将不再提供默认的构造方法。
    (2)构造方法的重载:如果自定义了带参构造方法,还要使用无参数构造方法,就必须再写一个无参数构造方法。
    (3)推荐的使用方式:无论是否使用,都手工书写无参数构造方法。


    10.3.5 标准类的制作

    (1)成员变量:使用private修饰
    (2)构造方法:提供一个无参构造方法、提供一个带多个参数的构造方法。
    (3)成员方法:提供每一个成员变量对应的setXxx() / getXxx();提供一个显示对象信息的show()。
    (4)创建对象并为其成员变量赋值的两种方式:无参构造方法创建对象后使用setXxx()赋值;使用带参构造方法直接创建带有属性值的对象。

    public class Student{
    	// 成员变量
    	private String name;
    	private int age;
    
    	// 构造方法
    	public Student() {}
    
    	public Student(String name, int age){
    		this.name = name;
    		this.age = age;
    	}
    
    	// 成员方法
    	public void setName(String name){
    		this.name = name;
    	}
    
    	public String getName(){
    		return name;
    	}
    
    	public void setAge(){
    		this.age = age;
    	}
    	
    	public int getAge(){
    		return age;
    	}
    
    	public void show(){
    		System.out.println(name + "," + age);
    	}
    
    }
    
    public class StudentTest{
    	public static void main(String[] args){
    		// 无参数构造方法创建对象后使用setXxx()赋值
    		Student s1 = new Student();
    		s1.setName("Kobe");
    		s1.setAge("24");
    		s1.show();
    
    		// 使用带参构造方法直接创建带有属性值的对象
    		Student s2 = new Student(name:"Kobe", age:24);
    		s2.show();
    
    	}
    
    }
    

    11. String

    String类在java.lang包下,所以使用的时候不需要导包。

    11.1 String构造方法

    在这里插入图片描述

    11.2 案例:用户登录

    package string;
    
    import java.util.Scanner;
    
    public class string001 {
        public static void main(String[] args){
             // 已知用户名和密码
            String username = "Kobe";
            String password = "24&8";
    
            // 用循环实现多次机会,这里的次数明确,采用for循环实现
            for(int i=0; i<3; i++){
    
                // 键盘要录入登录的用户名和密码,用Scanner实现
                Scanner sc = new Scanner(System.in);
    
                System.out.println("请输入用户名:");
                String name = sc.nextLine();
    
                System.out.println("请输入密码:");
                String pwd = sc.nextLine();
    
                // 用键盘录入的用户名和密码和已知的用户名和密码进行比较,并给出相应的提示
                if (username.equals(name) && password.equals(pwd)){
                    System.out.println("登录成功");
                    break;
                } else{
                    if ((2-i) == 0){
                        System.out.println("登录失败,你的账号已被冻结!");
                    } else{
                        System.out.println("用户名或密码输入错误,你还有" + (2-i) + "次输入机会!");
                    }
                }
            }
        }
    }
    

    11.3 案例:遍历字符串

    package string;
    
    import java.util.Scanner;
    
    public class string002 {
        public static void main(String[] args){
            // new一个Scanner对象接收输入的字符串
            Scanner sc = new Scanner(System.in);
    
            System.out.println("请输入一个字符串:");
            String line = sc.nextLine();
    
            // 定义for循环,用charAt()方法遍历字符串
            for (int i=0; i< line.length(); i++){
                System.out.println(line.charAt(i));
            }
        }
    

    11.4 StringBuilder


    11.4.1 StringBuilder概述

    StringBuilder是一个可变的字符串类,我们可以把它看成是一个容器,这里的可变指的是StringBuilder对象中的内容是可变的。

    11.4.2 String和StringBuilder的区别

    String的内容是不可变的;StringBuilder的内容是可变的。

    11.4.3 StringBuilder构造方法

    在这里插入图片描述

    package string;
    
    /*
        StringBuilder构造方法:
            public StringBuilder():创建一个空白可变字符串对象,不含有任何内容。
            public StringBuilder(String str):根据字符串的内容,来创建可变字符串对象。
     */
    
    public class string003 {
        public static void main(String[] args){
            // public StringBuilder()
            StringBuilder sb = new StringBuilder();
            System.out.println("sb:" + sb);
            System.out.println("sb.length():" + sb.length());
    
            // public StringBuilder(String str)
            StringBuilder sb2 = new StringBuilder("hello");
            System.out.println("sb2:" + sb2);
            System.out.println("sb2.length():" + sb2.length());
        }
    }
    

    11.4.4 StringBuilder的添加和反转方法

    在这里插入图片描述

    package string;
    
    /*
        StringBuilder的添加和反转方法:
            pubic StringBuilder append(任意类型):添加数据,并返回对象本身;
            public StringBuilder reverse(): 返回相反的字符序列
     */
    
    public class string004 {
        public static void main(String[] args){
            // 创建对象
            StringBuilder sb = new StringBuilder();
    
            // 链式编程
            sb.append("hello ").append("world ").append("!");
            System.out.println("sb: " + sb);
    
            // public StringBuilder reverse():返回相反的字符序列
            sb.reverse();
            System.out.println("sb: " + sb);
        }
    }
    

    11.4.5 StringBuilder 和 String 的相互转换

    1. StringBuilder转换为String

    public String toString():通过toString()就可以实现把StringBuilder转换为String。

    2. String转换为StringBuilder
    public StringBuilder(String s):通过构造方法就可以实现把String转换为StringBuilder。

    package string;
    
    public class string005 {
        public static void main(String[] args){
            // 先创建一个对象
            StringBuilder sb = new StringBuilder();
            sb.append("hello");
    
            // 将StringBuilder转换为String
            String s = sb.toString();
            System.out.println(s);
    
            // 将String转换为StringBuilder
            StringBuilder s2 = new StringBuilder(s);
            System.out.println(s2);
        }
    }
    

    11.4.6 案例:拼接字符串

    需求:定义一个方法,把int数组中的数据按照指定的格式拼接成一个字符串返回,调用该方法,并在控制台输出结果。例如,数组为int [] arr = {1, 2, 3}; ,执行方法后的输出结果为:[1,2,3]。

    public class string006 {
        public static void main(String[] args){
            int[] arr = {1,2,3,4,5};
    
            //调用方法,用一个变量接收结果
            String s = array2string(arr);          // 对数组的格式进行转换
    
            // 输出结果
            System.out.println(s);
    
    
        }
    
        public static String array2string(int[] arr){
            // 在方法中用 StringBuilder 按照要求进行拼接,并把结果转成 String 返回。
            StringBuilder sb = new StringBuilder();         // new一个StringBuilder对象
    
            sb.append('[');
    
            for (int i=0; i<arr.length; i++){
                if(i == arr.length-1){
                    sb.append(arr[i]);
                }
                else{
                    sb.append(arr[i]).append(',');              // 这里不可以用 + 号来拼接字符串
                }
            }
    
            sb.append(']');
    
            String s = sb.toString();
    
            return s;
        }
    }
    

    11.4.7 案例:字符串反转

    需求:定义一个方法,实现字符串反转。键盘录入一个字符串,调用该方法后,在控制台输出结果。例如,键盘录入abc,输出结果cba。

    import java.util.Scanner;
    
    public class string007 {
        public static void main(String[] args){
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入一个字符串:");
            String line = sc.nextLine();
    
            // 调用方法,传入输入的字符串,返回反转后的字符串
            String s = reverse(line);
    
            System.out.println(s);
        }
    
        public static String reverse(String s){
            StringBuilder sb = new StringBuilder(s);
            String reverse_s = sb.reverse().toString();
    
            return reverse_s;
            // 简便的语句:return new StringBuilder(s).reverse().toString();
        }
    }
    

    12. 集合

    12.1 集合基础

    集合类的特点:提供一种存储空间可变的存储模型,存储的数据容量可以发生改变。集合类有很多,本章着重介绍:ArrayList。
    **ArrayList:是可调整大小的数组实现。是一种特殊的数据类型,泛型。


    12.2 ArrayList构造方法和添加方法在这里插入图片描述


    12.3 ArrayList集合常用方法

    在这里插入图片描述

    展开全文
  • Javaweb基础全课程笔记黑马程序员上课笔记,主要涉及前端 jsp和servlet等
  • 黑马程序员Javase笔记

    2022-01-18 17:54:50
    正在自学黑马程序员Java全套,目前只学了Javase,接下来是Javaweb,把自己整理的笔记分享一下。
  • 黑马程序员JAVA学习笔记
  • 黑马程序员java笔记,看完就可以进行java程序编写,速度下载。基础全覆盖
  • Java常用类笔记(黑马)

    2021-12-12 13:33:50
    Java常用类笔记(黑马) String String概述 String构造方法 String对象的特点 字符串的比较 StringBuilder StringBuilder概述 StringBuilder构造方法 StringBuilder添加和反转 ...
  • day01_Object类、常用API day02_Collection、泛型 day03_List、Set、数据结构、Collections day04_Map,斗地主案例 day05_异常,线程 day06_线程、同步 day07_等待与唤醒案例、线程池、Lambda...Java基础小节练习题答案
  • 能够使用idea创建Java工程 能够使用idea创建包和类 了解idea的Java工程目录 了解idea字体的设置 掌握idea常用开发快捷键 了解项目的导入和删除 掌握方法定义的参数和返回值含义 了解方法的调用过程 了解方法的三种...
  • 黑马49期Java部分笔记

    2018-11-30 22:33:42
    资源为黑马49期Java部分笔记,包括cookie,session,html,css,js,http,servlet,javase,jdbc,jq,bootstrap,jsp,el,jstl,mysql xml,tomcat等笔记,都是老师上课截得屏,感觉比自己写容易理解,介意勿下载
  • 有关Java基础的笔记,希望对你们有帮助,哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈
  • 黑马程序员java培训就业班笔记:day06总结
  • 黑马java基础学习笔记第一天

    千次阅读 2018-10-16 21:17:40
    第1天 Java基础语法 今日内容介绍  Java开发环境搭建  HelloWorld案例  注释、关键字、标识符  数据(数据类型、常量) 第1章 Java开发环境搭建 1.1 Java概述 众所周知Java是一门编程语言,...
  • 黑马程序员SpringMVC课堂笔记
  • JAVA学习笔记.md

    2021-07-23 15:59:34
    JavaSE笔记
  • 1.Java8新特性全概括 2.允许在接口中有默认方法实现 3.Lambda表达式
  • 2016年黑马培训班-Java笔记2016年黑马培训班-Java笔记2016年黑马培训班-Java笔记
  • 希望各位管理员能给点币币咯Java黑马自学基础视频教程链接:http://pan.baidu.com/s/1pJXAjnP 密码:qj48Java黑马自学基础笔记 链接:http://pan.baidu.com/s/1jGUw7Jo 密码:kshq笔记需用第一天视频...
  • java基础笔记

    2018-05-29 21:05:15
    JAVA 基础讲解包括面向对象,javaSE,mysql,jdbc,web,笔记,练习等
  • 黑马程序员的学习笔记java基础

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 11,846
精华内容 4,738
关键字:

java黑马笔记

java 订阅