1.计算机语言的发展史
机器语言
汇编语言
高级语言
Java,C++,PHP
2. 变量
变量: 是一个容器,用来存储数据的
语法:
1.声明的同时直接赋值
数据类型 变量名 = 值;
// 数据类型: String 字符串数据类型
// 变量名 : 自己取的名字
// = : 赋值符号
// 值 : 数据
// ; : 代表语句结束
例子:
String name = "传智播客";// 定义一个变量
/*
String 数据类型 表示字符串的数据类型
name 是变量名 自己取的名字
= 赋值用的 把等于号右边的数据赋值给左边的变量
"" Java里面字符串就要用双引号引起来
; 代表语句结束
*/
2. 先声明后赋值
数据类型 变量名; // 代表声明了一个变量
变量名 = 值; // 把值赋给变量
String name;// 开辟了一块空间,空间的名字是name
name = "黑马程序员";// 赋值
注意:变量里面的数据是可以被覆盖的
变量命名的规则:
1.只能由字母(a_zA_Z),数字(0-9),下划线(_),美元符号($)组成
2.不能以数字开头 1name 错误
3.不能与关键字重名 关键字就是系统保留的字,具有特殊含义
4.严格区分大小写 name Name
变量命名的规范:
知名达意 驼峰命名法 String myName; 如果变量名有多个单词,那么就从第二个单词开始所有单词的首字母大写
String my_name;
常见的数据类型:
int double char String boolean(true\false)
数据类型:
1.常见的数据类型
2. 基本数据类型 4类8种
整数:
byte
short
int 整数直接写默认是int类型 正负21亿之间
long
小数:
float float类型的值必须加f\F,不加会报错
double 小数直接写默认是double类型
字符:
char 字符类型的值必须要用单引号引起来,并且单引号只能有一个字符
布尔:
boolean (true\false)
3. 引用数据类型 String 字符串
1KB = 1024字节;
1MB = 1024KB;
1GB = 1024MB;
1.变量
概述:就是一个容器,用于存储数据的
语法:
1.声明的同时直接赋值
数据类型 变量名 = 值;
String name = "传智播o客";
2.先声明后赋值
声明: 数据类型 变量名; String name;
赋值: 变量名 = 值; name = "黑马程序员";
标识符命名规则:
1.只能由字母,数字,下划线,美元符号组成
2.不能以数字开头
3.不能与关键字重名
4.严格区分大小写
标识符命名规范:
知名达意
2.运算符
算术运算符: + - * / %
注意:2个整数相除,得到的结果一定是整数
比较运算符: > >= < <= == !=
// 比较表达式的结果一定是 boolean 类型的数据,所以比较表达式可以作为if结构的条件判断
逻辑运算符:
// 逻辑运算符的2边一定要是 boolean 类型的数据
/*
&& 逻辑与 只要有false,逻辑&&表达式的结果就是 false,只有当两边同时为true ,逻辑&&表达式的结果才是true
遇 false ,则 false
|| 逻辑或 只要有true,逻辑||表达式的结果就是 true,只有当两边同时为 false,逻辑||表达式的结果才是 false;
遇 true ,则 true
! 逻辑非 真变假 假变真
& 遇 false 则 false
| 遇 true ,则 true
*/
&& 短路的问题 只要逻辑&&的左边为 false ,逻辑&&的右边就不会运算
|| 短路的问题 只要逻辑||的左边为 true,逻辑||的右边就不会运算
复合赋值运算符: = += -= *= /= %=
自增\自减运算符:
++ --
// 表达式的值 变量的值
// 表达式 : 由运算符连接起来的式子就是表达式
// ++ 运算符
/*
num++ 后自增表达式:
运算法则:先取变量(num)自身的值作为表达式的值,然后将变量自身+1
++num 前自增表达式:
运算法则:先将变量自身的值+1,然后将变量的值作为表达式的值
总结: 不管是前自增还是后自增,变量自身的值都得+1
num-- 后自减表达式:
运算法则:先取变量(num)自身的值作为表达式的值,然后将变量自身-1
--num 前自减表达式:
运算法则:先将变量自身的值-1,然后将变量的值作为表达式的值
总结:不管是前自减还是后自减,变量自身的值都得-1
*/
// int num = 3;
//
// int res = ++num - num-- - ++num + num++ + ++num;
// 4/4 4/3 4/4 4/5 6/6
// int res = (++num) - (num--) - (++num) + (num++) + (++num);// 4-4-4+4+6
// System.out.println(res);//6
// System.out.println(num);//6
// int num = 3;
// int res = num--;
// System.out.println(res);//3
// System.out.println(num);//2
// int num = 3;
// int res = --num;
// System.out.println(res);//2
// System.out.println(num);//2
// int num = 3;
// int res = ++num;
// System.out.println(res);//4
// System.out.println(num);//4
// int num = 3;
// int res = num++;
// System.out.println(res);//3
// System.out.println(num);//4
3.定义类\定义方法
定义类的语法:
public class 类名{// 类名:符合标识符命名规则 从第一个单词开始所有单词的首字母大写
// 属性(变量)
// 方法(方法)
}
定义方法的语法:
public 返回值类型 方法名(数据类型 参数1,数据类型 参数2,...){
// 方法体
返回值: 根据方法的功能是否有返回值,如果方法没有返回值,返回值类型就是 void
如果有返回值,返回值的数据类型就是方法的返回值类型,并且要有 return 语句
方法名: 自己取
参数: 用来传递数据的
}
注意:
1.方法和方法之间是平行关系
2.方法不调用不会执行
4. 选择结构
补充:
// 成员变量: 定义在类里面,方法的外面的变量,系统会自动赋默认值
// 局部变量: 定义在方法里面的变量,系统不会赋默认值
// 变量没有赋值是不能直接使用的
常用的数据类型 初始值
int 0
float 0.0
double 0.0
char 空(0)
String null
boolean false
3.运算符:
算术运算符: + - * / %(取模\取余数)
注意: 2个整数相除,得到的结果一定是整数(取整数部分)
比较运算符:
逻辑运算符:
赋值运算符: =
4.程序的结构
顺序结构
分支\选择结构
1.
if(条件语句){
// 任意的代码 条件成立,就会执行,条件不成立,就不会执行
}
2.
if(条件){
// 条件成立,就会执行的代码 1
}else{
// 条件不成立,就会执行的代码 2
}
// 所以代码1 和代码2 不会同时执行,也不会同时不执行
3.
if(条件1){
// 代码1
}else if(条件2){
// 代码2
}else if(条件3){
// 代码3
}else{
// 代码4
}
循环结构:
5.注释
// 注释: 大白话就是用来解释代码的,给程序员看的,不参与程序的运行
// 分类:
// 单行注释 // 添加\取消单行注释快捷键 ctrl + /
// 多行注释
/*
多行注释
注意: 多行注释不能嵌套多行注释
*/
// 文档注释
/**
文档注释 主要用于注释类\方法
*/
6.定义类和方法
如何写类
概念: 就是一群具有相同特征和行为的事物的统称
语法:
权限修饰符 class 类名{
// 类的特征\属性
// 类的行为\方法
}
权限修饰符: public
类名: 自己取的名字 符合标识符命名规则和规范 类名是从第一个单词开始每个单词的首字母大写
如何写方法
简单的方法: 无参数无返回值的方法
语法:
权限修饰符 返回值类型 方法名(数据类型 参数名1,数据类型 参数名2,....){
// 方法体\功能代码
}
权限修饰符: public
返回值类型: 无返回值 void
有返回值 返回的数据是什么数据类型那么返回值类型就是什么数据类型
方法名: 自己取 符合标识符命名规则和规范 方法名是从第二个单词开始每个单词的首字母大写
参数: 用来传递数据的 如果不需要外界传数据 那就空着
方法体: 功能代码\执行的代码
注意: 方法不调用不会执行
调用方法:
方法名(实际参数); // 实际参数: 具体的值
1. 自己定义的方法
1.明确方法的返回值类型 ---> 有返回值 ---> 整数int
2.明确方法名 --> 自己定义 ---> add
3.明确方法的参数 ---> 2个参数 都是 int 类型
4.明确方法的功能
2. 调用别人的方法
1.明确方法的功能
2.明确方法的方法名
3.明确方法的参数
4.明确方法的返回值
// add() 加法 ----> 计算2个整数之和
10 + 30
40 - 2
调用方法的语法:
方法名(实际参数);
知识点补充:
1.java语言是严格区分大小写
2.面向过程:按照步骤一步一步执行
3.面向对象:找专业的人做专业的事情
4.字符串的相加: 其实就是拼接
// 补充: 任何数据类型的数据和字符串相加,就会拼接成一个新的字符串
System.out.println(5+"heima");//5heima alt + /
System.out.println(5+5+"heima");//10hiema
System.out.println("heima"+5);// heima5
System.out.println("heima"+5+5);//hiema55
// 引用数据类型: String
// 1.隐式类型转换 把小范围的数据 赋值给 大范围的变量 会自动转换
double d = 14;
// 2.强制类型转换 把大范围的数据 赋值给 小范围的变量
int num = (int)1.73;
面向对象与面向过程
面向过程: 第一步做什么,第二步,第三步做什么
面向对象:调用对象的方法做事情
万物皆对象
在Java语言中,我们通过类创建对象
属性:事物体现的外在特征,名词 ==> 成员变量
行为:事物能够做什么, 动词 ==> 成员方法
通过Java语言去描述事物
1.定义类
定义成员变量
定义成员方法
2.使用这个类创建对象
创建对象,调用对象的属性和行为
类与对象
类:具有一组相关属性和行为的集合, 模版,图纸
对象:该类事物的具体体现,具体的产品
封装
把对象的属性和访问细节给隐藏起来, 仅对外提供公共的访问方式
1. 不能让别人直接访问我的成员变量 --> 通过private关键字
2. 提供公共的访问方式 --> 通过set方法赋值, 通过get方法取值
变量访问的原则: 就近原则. 也就是说, 局部位置有, 就使用局部变量. 局部位置没有, 才去找成员变量.
this
代表当前的这个对象
用来解决局部变量与成员变量的重名问题
构造方法
构造方法有且仅有一个作用, 那就是用来创建对象
当我们没有写构造方法时, 系统会为我们默认提供一个无参构造. 当我们写了构造方法时, 系统就不会再给我们提供默认的无参构造了
构造方法的格式
public 类名(xxx){
}
注意:
方法名与类名一致,连大小写也要一样
构造方法没有返回值类型, 连void也没有
有参构造与带参构造的区别
共同点: 无论是有参构造还是无参构造, 都创建出了对象
区别: 带参构造在创建对象的同时, 为属性进行了赋值
数组的两种定义方式
静态初始化方式: String[] names = {"A","B","C","D","E"};
动态初始化方式: String[] names = new String[5];
数组的索引
数组在内存中是连续的, 所以我们可以通过索引去找到对应位置的元素. 在Java语言中我们规定,数组的索引是从0开始的.
获取数组中的元素
根据索引获取对应位置上的元素: 数组名[索引]
数组的长度
数组名.length
数组中的最大索引,最后一个元素对应的索引
数组的长度-1
1. static ---> 静态的意思
修饰成员变量: ----> 静态成员变量
1. 资源共享,被static修饰的成员变量会被该类下的所有对象共享,也就是说所有对象使用的是同一份数据
2. 可以用类名.属性名去访问
修饰成员方法: ---> 静态方法
1. 位置: 返回值类型之前
2. 可以用类名.方法名调用方法(不用创建对象了)
注意:
1. 静态方法里面不可以有this
2. 静态方法里面只能直接使用静态(静态成员变量\静态成员方法)
2. 包:
概述: 文件夹
导包: ctrl + shift + o
// java.lang 这个包下的类是不需要导包的,其他的都需要导包
3. 工具类:
是一个概念,一般工具类的文件名为 功能名称+Utils
工具类里面的方法一般都是静态方法,也就是被static修饰的方法
4. final 终态
final 关键字一旦修饰了变量,这个变量就变成了常量,无法再次被修改了
修饰成员变量:成员变量用了final 修饰就会变成常量 常量是不能更改的
final 修饰成员变量,只能在定义的时候赋值,并且只能赋值一次
工具类里面的属性: 一般的修饰符是: public static final
局部变量:修饰局部变量 变成常量,而常量只能赋值一次
5. RPG游戏
特点:
0. 交谈: 玩家和电脑人交谈,电脑人会回答玩家 ,玩家不主动跟电脑人交谈,电脑人不会跟玩家交谈
1. 回合制游戏 玩家攻击电脑人,电脑人受伤(掉血),电脑人反击玩家,玩家受伤(掉血)
2. 玩家不攻击电脑人,电脑人是不会攻击玩家的
3. 如果没有攻击到,也就是说避开了,就不会掉血
4. 血量为0之后,就会退出游戏
类: 类名 属性 方法
玩家类:
属性: 姓名 血量
方法:
1. 跟电脑人交谈的方法
2. 攻击电脑人
3. 受伤的方法
电脑人:
属性: 姓名 血量
方法:
1. 回答玩家
2. 受伤的方法
3. 反击玩家
游戏界面类: 测试类
1.循环
概述: 一件事情反复不停的做就叫做循环
A:循环结构的分类
????* for,while,do...while?
1) while 循环
语法:
初始化语句;
?????while(判断条件语句) {
????????????循环体语句;
????????????控制条件语句;
??????}
?B:执行流程:
????* a:执行初始化语句
????* b:执行判断条件语句,看其返回值是true还是false
????????* 如果是true,就继续执行
????????* 如果是false,就结束循环
????* c:执行循环体语句;
????* d:执行控制条件语句
????* e:回到B继续。
例子:
int i = 0; ① //初始化条件
while(i < 10) { ② //判断条件
System.out.println(i); ④ //循环体
i++;③ //控制条件
}
执行顺序:
第一次: ①, ②, ④, ③
第二次: ②, ④, ③
第三次: ②, ④, ③
......
最后一次: ② //条件满足就执行循环体,不满足就结束循环
//判断条件永远比 控制条件多执行一次.
练习:
简单版:
使用while循环,打印10次我要来黑马学习
进阶版:
让用户输入密码88888,如果输入错误就重新输入,直到输入正确为止
请打印 1-100 之间可以被 8 整除的数
2) do...while 循环
语句的格式:
????????do {
????????????循环体语句;
????????}while(判断条件语句);
????????
????????
完整格式;
????????初始化语句;
????????do {
????????????循环体语句;
????????????控制条件语句;
????????}while(判断条件语句);
?B:执行流程:
????* a:执行初始化语句
????* b:执行循环体语句;
????* c:执行控制条件语句
????* d:执行判断条件语句,看其返回值是true还是false
????????* 如果是true,就继续执行
????????* 如果是false,就结束循环
????* e:回到b继续。
例子:
int i = 0; ① //初始化条件
do{ ② //判断条件
System.out.println(i); ④ //循环体
i++;③ //控制条件
}while(i < 10)
3) for 循环
?B:循环结构for语句的格式:
????????for(初始化表达式;条件表达式;循环后的操作表达式) {
????????????循环体;
????????}
?C执行流程:
????* a:执行初始化语句
????* b:执行判断条件语句,看其返回值是true还是false
????????* 如果是true,就继续执行
????????* 如果是false,就结束循环
????* c:执行循环体语句;
????* d:执行循环后的操作表达式
????* e:回到B继续。
例子:
① ② ③
for(int i=0; i<10; i++) { //这个循环的作用是: 打印0-9之间的数字
④
System.out.println(i); //这是循环体
}
执行顺序:
第一次: ①, ②, ④, ③
第二次: ②, ④, ③
第三次: ②, ④, ③
......
最后一次: ② //条件满足就执行循环体,不满足就结束循环
4) 增强for循环
格式:
for(数据类型 变量名 : 要遍历的集合或者数组) {
//正常的功能代码
}
双重for循环
// 外层循环控制行,内层循环控制列
// 外层循环一次,内层循环所有次
正则:
*?需求:?
?????* 定义一个工具类RegexUtils, 在该类中定义一个方法checkPhoneNumber(Strnig phone);
?????* 用来校验指定的字符串是否是合法的手机号.
?????* 手机号规则:
?????????* 1.长度必须是11位.
?????????* 2.必须是纯数字
?????????* 3.必须是数字1开头的.
?????????* 4.第二位数字必须是3,4,5,7,8
1.HashMap:
2.ArrayList:
分类: 此处先写三个循环
普通for循环:
格式:
① ② ③
for(循环初始语句;循环条件语句 ;改变控制循环变量语句 ) { //这个循环的作用是: 打印0-9之间的数字
④
System.out.println(i); //这是循环体
}
① ② ③
for(int i=0; i<次数; i++) { //这个循环的作用是: 打印0-9之间的数字
④
System.out.println(i); //这是循环体
}
执行顺序:
第一次: ①, ②, ④, ③
第二次: ②, ④, ③
第三次: ②, ④, ③
......
最后一次: ② //条件满足就执行循环体,不满足就结束循环
增强for循环;
for(数据类型 变量名 : 要遍历的集合或者数组) {
//正常的功能代码
}
集合的遍历:
HashMap集合的遍历:
// 增强for循环
// 1.获取所有键的集合 单列集合
// 2.遍历所有键的集合 获取每一个键
// 3.根据获取到的键去取值
1.继承
概述:在开发中,我们发现多个类具有很多相似的功能,于是我们就把这些相似的功能放到一个类中,然后让这多个类和这个类产生一个关系,
这个关系就叫做继承
关键字: extends
语法:
public class A类 extends B类{
}
认识:
A类: 子类,派生类
B类: 父类,基类,超类
特点:
1.子类继承父类,只能单继承,不能多继承,但是可以多层继承
2.子类继承父类,就拥有父类里面的非私有属性\方法
继承中成员变量的访问特点:
使用变量遵循"就近原则", 先在局部位置找, 有就使用, 没有就去本类的成员位置找,?
???? ?* 有就使用, 没有就去父类的成员位置找,有就使用, 没有就报错.
注意事项:
* 1.子类继承父类,不能继承父类的私有属性和私有方法
* 2.子类继承父类,不能继承父类的构造方法,但是可以使用
* 关键字: super
* 调用父类的空参构造方法: super();
* 调用父类的有参构造方法: super(参数);
*
* 直接调用父类的普通方法; super.方法名();
* 直接访问父类的属性: super.属性名
* 3.不要为了继承而继承
* Dog 属性:姓名 年龄
* 方法: 吃东西
*
* Person 属性: 姓名 年龄
* 方法: 吃东西
*
* 程序员:
* 属性: 姓名 工号 薪资
* 方法; 写代码
*
* 项目经理:
* 属性:姓名 工号 薪资 奖金
* 方法: 写代码 审计代码
* 4. 满足 is a 的关系
* 学生 属于 人类
* 子类 属于 父类
方法的重写:
概述: 子类出现和父类一模一样的方法
为什么要重写方法?
1.父类的功能无法满足子类的需求
2.当子类具有特有的功能的时候
重写的注意事项:
1.父类的私有方法不能重写
2.子类重写父类的方法,重写的方法的访问权限不能低于父类的访问权限
private(本类) < protected(同一个包) < 默认(本类和子类) < public(当前项目中)
3.静态方法严格意义上来讲不是方法的重写(只是表现形式和方法的重写意义)
方法的重载:
概述: 方法名一致,方法的参数不一致(参数的数据类型不一致,参数的个数不一致)
final 关键字
1.修饰类
被final修饰的类不能被子类继承
2. 修饰方法
被fianl修饰的方法不能被子类重写
3. 修饰变量
被final修饰的变量会变成一个常量,常量只能赋值一次
2. 多态
多态指的是: 同一种行为,对于不同的事物具有不同的表现形式。 这就叫做多态。
医生 咔 动手术
理发师 咔 剪头发
演员 咔 停止了
程序中的多态:不同的对象 以 自己的方式响应 相同名称方法的能力称为多态
Dog 吃 吃骨头
Cat 吃 鱼
Monkey 吃 香蕉
多态的条件:
1. 继承
2. 方法的重写
3. 父类的引用指向子类的对象
多态的使用\好处:
1. 开发中使用父类的类型作为方法的参数类型声明,那么以后不管传入任意的子类对象,都可以接收。
2.在调用方法的时候,调用的是子类的方法,前提是父类必须要有该方法,不然会编译不通过。
多态成员访问特点:
多态的成员访问特点:
成员变量: 编译看左边,运行看左边
成员方法:
静态方法: 编译看左边,运行看左边
非静态方法: 编译看左边,运行看右边
总结: 除了非静态方法是编译看左边,运行看右边,其他情况都是编译看左边,运行看左边
向下转型:
Animal anl = new Dog();// 向上转型
Dog dog = (Dog)animal;// 向下转型
dog.lookHome();
3.抽象类:
抽象方法: 没有方法体的方法就是抽象方法 一般用 abstract
抽象类: 用 abstract修饰的类就是抽象类, 有抽象方法的类一定是抽象类
特点:
1.有抽象方法的类一定是抽象类
2.不能创建对象,通过其子类来创建对象
3.可以有构造方法,但是不能用来创建对象,
用于子类对象访问父类数据之前,对父类的属性初始化
3.子类:
普通类: 必须要实现父类的抽象方法
抽象类: 不一定要实现父类的抽象方法
4.接口:
概述:用 Interface 定义的就是接口
实现:
public class 类A implements 接口{
}
public class 类A extends 类B implements 接口{
}
特点:
1. 定义接口 使用的关键字是 Interface
2. 实现接口 使用的关键字是 implements
3. 不能有构造方法,也不能创建对象,通过实现类来创建对象
4. 实现类:
普通类: 一定要实现接口中的抽象方法
抽象类: 不一定要实现接口中的抽象方法
成员特点:
JDK1.7及以前的:
成员变量: 默认修饰符 public static final
成员方法: 只能是抽象方法 默认修饰符 public abstract
JDK1.8:
成员变量:默认修饰符 public static final
成员方法: 增加了有方法体的方法,非静态方法,需要加 default 修饰,静态方法就直接写
接口:
类:
类和类的关系:
类和接口的关系:
接口和接口的关系:
接口和抽象类的区别:
机器语言
汇编语言
高级语言
Java,C++,PHP
2. 变量
变量: 是一个容器,用来存储数据的
语法:
1.声明的同时直接赋值
数据类型 变量名 = 值;
// 数据类型: String 字符串数据类型
// 变量名 : 自己取的名字
// = : 赋值符号
// 值 : 数据
// ; : 代表语句结束
例子:
String name = "传智播客";// 定义一个变量
/*
String 数据类型 表示字符串的数据类型
name 是变量名 自己取的名字
= 赋值用的 把等于号右边的数据赋值给左边的变量
"" Java里面字符串就要用双引号引起来
; 代表语句结束
*/
2. 先声明后赋值
数据类型 变量名; // 代表声明了一个变量
变量名 = 值; // 把值赋给变量
String name;// 开辟了一块空间,空间的名字是name
name = "黑马程序员";// 赋值
注意:变量里面的数据是可以被覆盖的
变量命名的规则:
1.只能由字母(a_zA_Z),数字(0-9),下划线(_),美元符号($)组成
2.不能以数字开头 1name 错误
3.不能与关键字重名 关键字就是系统保留的字,具有特殊含义
4.严格区分大小写 name Name
变量命名的规范:
知名达意 驼峰命名法 String myName; 如果变量名有多个单词,那么就从第二个单词开始所有单词的首字母大写
String my_name;
常见的数据类型:
int double char String boolean(true\false)
数据类型:
1.常见的数据类型
2. 基本数据类型 4类8种
整数:
byte
short
int 整数直接写默认是int类型 正负21亿之间
long
小数:
float float类型的值必须加f\F,不加会报错
double 小数直接写默认是double类型
字符:
char 字符类型的值必须要用单引号引起来,并且单引号只能有一个字符
布尔:
boolean (true\false)
3. 引用数据类型 String 字符串
1KB = 1024字节;
1MB = 1024KB;
1GB = 1024MB;
1.变量
概述:就是一个容器,用于存储数据的
语法:
1.声明的同时直接赋值
数据类型 变量名 = 值;
String name = "传智播o客";
2.先声明后赋值
声明: 数据类型 变量名; String name;
赋值: 变量名 = 值; name = "黑马程序员";
标识符命名规则:
1.只能由字母,数字,下划线,美元符号组成
2.不能以数字开头
3.不能与关键字重名
4.严格区分大小写
标识符命名规范:
知名达意
2.运算符
算术运算符: + - * / %
注意:2个整数相除,得到的结果一定是整数
比较运算符: > >= < <= == !=
// 比较表达式的结果一定是 boolean 类型的数据,所以比较表达式可以作为if结构的条件判断
逻辑运算符:
// 逻辑运算符的2边一定要是 boolean 类型的数据
/*
&& 逻辑与 只要有false,逻辑&&表达式的结果就是 false,只有当两边同时为true ,逻辑&&表达式的结果才是true
遇 false ,则 false
|| 逻辑或 只要有true,逻辑||表达式的结果就是 true,只有当两边同时为 false,逻辑||表达式的结果才是 false;
遇 true ,则 true
! 逻辑非 真变假 假变真
& 遇 false 则 false
| 遇 true ,则 true
*/
&& 短路的问题 只要逻辑&&的左边为 false ,逻辑&&的右边就不会运算
|| 短路的问题 只要逻辑||的左边为 true,逻辑||的右边就不会运算
复合赋值运算符: = += -= *= /= %=
自增\自减运算符:
++ --
// 表达式的值 变量的值
// 表达式 : 由运算符连接起来的式子就是表达式
// ++ 运算符
/*
num++ 后自增表达式:
运算法则:先取变量(num)自身的值作为表达式的值,然后将变量自身+1
++num 前自增表达式:
运算法则:先将变量自身的值+1,然后将变量的值作为表达式的值
总结: 不管是前自增还是后自增,变量自身的值都得+1
num-- 后自减表达式:
运算法则:先取变量(num)自身的值作为表达式的值,然后将变量自身-1
--num 前自减表达式:
运算法则:先将变量自身的值-1,然后将变量的值作为表达式的值
总结:不管是前自减还是后自减,变量自身的值都得-1
*/
// int num = 3;
//
// int res = ++num - num-- - ++num + num++ + ++num;
// 4/4 4/3 4/4 4/5 6/6
// int res = (++num) - (num--) - (++num) + (num++) + (++num);// 4-4-4+4+6
// System.out.println(res);//6
// System.out.println(num);//6
// int num = 3;
// int res = num--;
// System.out.println(res);//3
// System.out.println(num);//2
// int num = 3;
// int res = --num;
// System.out.println(res);//2
// System.out.println(num);//2
// int num = 3;
// int res = ++num;
// System.out.println(res);//4
// System.out.println(num);//4
// int num = 3;
// int res = num++;
// System.out.println(res);//3
// System.out.println(num);//4
3.定义类\定义方法
定义类的语法:
public class 类名{// 类名:符合标识符命名规则 从第一个单词开始所有单词的首字母大写
// 属性(变量)
// 方法(方法)
}
定义方法的语法:
public 返回值类型 方法名(数据类型 参数1,数据类型 参数2,...){
// 方法体
返回值: 根据方法的功能是否有返回值,如果方法没有返回值,返回值类型就是 void
如果有返回值,返回值的数据类型就是方法的返回值类型,并且要有 return 语句
方法名: 自己取
参数: 用来传递数据的
}
注意:
1.方法和方法之间是平行关系
2.方法不调用不会执行
4. 选择结构
补充:
// 成员变量: 定义在类里面,方法的外面的变量,系统会自动赋默认值
// 局部变量: 定义在方法里面的变量,系统不会赋默认值
// 变量没有赋值是不能直接使用的
常用的数据类型 初始值
int 0
float 0.0
double 0.0
char 空(0)
String null
boolean false
3.运算符:
算术运算符: + - * / %(取模\取余数)
注意: 2个整数相除,得到的结果一定是整数(取整数部分)
比较运算符:
逻辑运算符:
赋值运算符: =
4.程序的结构
顺序结构
分支\选择结构
1.
if(条件语句){
// 任意的代码 条件成立,就会执行,条件不成立,就不会执行
}
2.
if(条件){
// 条件成立,就会执行的代码 1
}else{
// 条件不成立,就会执行的代码 2
}
// 所以代码1 和代码2 不会同时执行,也不会同时不执行
3.
if(条件1){
// 代码1
}else if(条件2){
// 代码2
}else if(条件3){
// 代码3
}else{
// 代码4
}
循环结构:
5.注释
// 注释: 大白话就是用来解释代码的,给程序员看的,不参与程序的运行
// 分类:
// 单行注释 // 添加\取消单行注释快捷键 ctrl + /
// 多行注释
/*
多行注释
注意: 多行注释不能嵌套多行注释
*/
// 文档注释
/**
文档注释 主要用于注释类\方法
*/
6.定义类和方法
如何写类
概念: 就是一群具有相同特征和行为的事物的统称
语法:
权限修饰符 class 类名{
// 类的特征\属性
// 类的行为\方法
}
权限修饰符: public
类名: 自己取的名字 符合标识符命名规则和规范 类名是从第一个单词开始每个单词的首字母大写
如何写方法
简单的方法: 无参数无返回值的方法
语法:
权限修饰符 返回值类型 方法名(数据类型 参数名1,数据类型 参数名2,....){
// 方法体\功能代码
}
权限修饰符: public
返回值类型: 无返回值 void
有返回值 返回的数据是什么数据类型那么返回值类型就是什么数据类型
方法名: 自己取 符合标识符命名规则和规范 方法名是从第二个单词开始每个单词的首字母大写
参数: 用来传递数据的 如果不需要外界传数据 那就空着
方法体: 功能代码\执行的代码
注意: 方法不调用不会执行
调用方法:
方法名(实际参数); // 实际参数: 具体的值
1. 自己定义的方法
1.明确方法的返回值类型 ---> 有返回值 ---> 整数int
2.明确方法名 --> 自己定义 ---> add
3.明确方法的参数 ---> 2个参数 都是 int 类型
4.明确方法的功能
2. 调用别人的方法
1.明确方法的功能
2.明确方法的方法名
3.明确方法的参数
4.明确方法的返回值
// add() 加法 ----> 计算2个整数之和
10 + 30
40 - 2
调用方法的语法:
方法名(实际参数);
知识点补充:
1.java语言是严格区分大小写
2.面向过程:按照步骤一步一步执行
3.面向对象:找专业的人做专业的事情
4.字符串的相加: 其实就是拼接
// 补充: 任何数据类型的数据和字符串相加,就会拼接成一个新的字符串
System.out.println(5+"heima");//5heima alt + /
System.out.println(5+5+"heima");//10hiema
System.out.println("heima"+5);// heima5
System.out.println("heima"+5+5);//hiema55
// 引用数据类型: String
// 1.隐式类型转换 把小范围的数据 赋值给 大范围的变量 会自动转换
double d = 14;
// 2.强制类型转换 把大范围的数据 赋值给 小范围的变量
int num = (int)1.73;
面向对象与面向过程
面向过程: 第一步做什么,第二步,第三步做什么
面向对象:调用对象的方法做事情
万物皆对象
在Java语言中,我们通过类创建对象
属性:事物体现的外在特征,名词 ==> 成员变量
行为:事物能够做什么, 动词 ==> 成员方法
通过Java语言去描述事物
1.定义类
定义成员变量
定义成员方法
2.使用这个类创建对象
创建对象,调用对象的属性和行为
类与对象
类:具有一组相关属性和行为的集合, 模版,图纸
对象:该类事物的具体体现,具体的产品
封装
把对象的属性和访问细节给隐藏起来, 仅对外提供公共的访问方式
1. 不能让别人直接访问我的成员变量 --> 通过private关键字
2. 提供公共的访问方式 --> 通过set方法赋值, 通过get方法取值
变量访问的原则: 就近原则. 也就是说, 局部位置有, 就使用局部变量. 局部位置没有, 才去找成员变量.
this
代表当前的这个对象
用来解决局部变量与成员变量的重名问题
构造方法
构造方法有且仅有一个作用, 那就是用来创建对象
当我们没有写构造方法时, 系统会为我们默认提供一个无参构造. 当我们写了构造方法时, 系统就不会再给我们提供默认的无参构造了
构造方法的格式
public 类名(xxx){
}
注意:
方法名与类名一致,连大小写也要一样
构造方法没有返回值类型, 连void也没有
有参构造与带参构造的区别
共同点: 无论是有参构造还是无参构造, 都创建出了对象
区别: 带参构造在创建对象的同时, 为属性进行了赋值
数组的两种定义方式
静态初始化方式: String[] names = {"A","B","C","D","E"};
动态初始化方式: String[] names = new String[5];
数组的索引
数组在内存中是连续的, 所以我们可以通过索引去找到对应位置的元素. 在Java语言中我们规定,数组的索引是从0开始的.
获取数组中的元素
根据索引获取对应位置上的元素: 数组名[索引]
数组的长度
数组名.length
数组中的最大索引,最后一个元素对应的索引
数组的长度-1
1. static ---> 静态的意思
修饰成员变量: ----> 静态成员变量
1. 资源共享,被static修饰的成员变量会被该类下的所有对象共享,也就是说所有对象使用的是同一份数据
2. 可以用类名.属性名去访问
修饰成员方法: ---> 静态方法
1. 位置: 返回值类型之前
2. 可以用类名.方法名调用方法(不用创建对象了)
注意:
1. 静态方法里面不可以有this
2. 静态方法里面只能直接使用静态(静态成员变量\静态成员方法)
2. 包:
概述: 文件夹
导包: ctrl + shift + o
// java.lang 这个包下的类是不需要导包的,其他的都需要导包
3. 工具类:
是一个概念,一般工具类的文件名为 功能名称+Utils
工具类里面的方法一般都是静态方法,也就是被static修饰的方法
4. final 终态
final 关键字一旦修饰了变量,这个变量就变成了常量,无法再次被修改了
修饰成员变量:成员变量用了final 修饰就会变成常量 常量是不能更改的
final 修饰成员变量,只能在定义的时候赋值,并且只能赋值一次
工具类里面的属性: 一般的修饰符是: public static final
局部变量:修饰局部变量 变成常量,而常量只能赋值一次
5. RPG游戏
特点:
0. 交谈: 玩家和电脑人交谈,电脑人会回答玩家 ,玩家不主动跟电脑人交谈,电脑人不会跟玩家交谈
1. 回合制游戏 玩家攻击电脑人,电脑人受伤(掉血),电脑人反击玩家,玩家受伤(掉血)
2. 玩家不攻击电脑人,电脑人是不会攻击玩家的
3. 如果没有攻击到,也就是说避开了,就不会掉血
4. 血量为0之后,就会退出游戏
类: 类名 属性 方法
玩家类:
属性: 姓名 血量
方法:
1. 跟电脑人交谈的方法
2. 攻击电脑人
3. 受伤的方法
电脑人:
属性: 姓名 血量
方法:
1. 回答玩家
2. 受伤的方法
3. 反击玩家
游戏界面类: 测试类
1.循环
概述: 一件事情反复不停的做就叫做循环
A:循环结构的分类
????* for,while,do...while?
1) while 循环
语法:
初始化语句;
?????while(判断条件语句) {
????????????循环体语句;
????????????控制条件语句;
??????}
?B:执行流程:
????* a:执行初始化语句
????* b:执行判断条件语句,看其返回值是true还是false
????????* 如果是true,就继续执行
????????* 如果是false,就结束循环
????* c:执行循环体语句;
????* d:执行控制条件语句
????* e:回到B继续。
例子:
int i = 0; ① //初始化条件
while(i < 10) { ② //判断条件
System.out.println(i); ④ //循环体
i++;③ //控制条件
}
执行顺序:
第一次: ①, ②, ④, ③
第二次: ②, ④, ③
第三次: ②, ④, ③
......
最后一次: ② //条件满足就执行循环体,不满足就结束循环
//判断条件永远比 控制条件多执行一次.
练习:
简单版:
使用while循环,打印10次我要来黑马学习
进阶版:
让用户输入密码88888,如果输入错误就重新输入,直到输入正确为止
请打印 1-100 之间可以被 8 整除的数
2) do...while 循环
语句的格式:
????????do {
????????????循环体语句;
????????}while(判断条件语句);
????????
????????
完整格式;
????????初始化语句;
????????do {
????????????循环体语句;
????????????控制条件语句;
????????}while(判断条件语句);
?B:执行流程:
????* a:执行初始化语句
????* b:执行循环体语句;
????* c:执行控制条件语句
????* d:执行判断条件语句,看其返回值是true还是false
????????* 如果是true,就继续执行
????????* 如果是false,就结束循环
????* e:回到b继续。
例子:
int i = 0; ① //初始化条件
do{ ② //判断条件
System.out.println(i); ④ //循环体
i++;③ //控制条件
}while(i < 10)
3) for 循环
?B:循环结构for语句的格式:
????????for(初始化表达式;条件表达式;循环后的操作表达式) {
????????????循环体;
????????}
?C执行流程:
????* a:执行初始化语句
????* b:执行判断条件语句,看其返回值是true还是false
????????* 如果是true,就继续执行
????????* 如果是false,就结束循环
????* c:执行循环体语句;
????* d:执行循环后的操作表达式
????* e:回到B继续。
例子:
① ② ③
for(int i=0; i<10; i++) { //这个循环的作用是: 打印0-9之间的数字
④
System.out.println(i); //这是循环体
}
执行顺序:
第一次: ①, ②, ④, ③
第二次: ②, ④, ③
第三次: ②, ④, ③
......
最后一次: ② //条件满足就执行循环体,不满足就结束循环
4) 增强for循环
格式:
for(数据类型 变量名 : 要遍历的集合或者数组) {
//正常的功能代码
}
双重for循环
// 外层循环控制行,内层循环控制列
// 外层循环一次,内层循环所有次
正则:
*?需求:?
?????* 定义一个工具类RegexUtils, 在该类中定义一个方法checkPhoneNumber(Strnig phone);
?????* 用来校验指定的字符串是否是合法的手机号.
?????* 手机号规则:
?????????* 1.长度必须是11位.
?????????* 2.必须是纯数字
?????????* 3.必须是数字1开头的.
?????????* 4.第二位数字必须是3,4,5,7,8
1.HashMap:
2.ArrayList:
分类: 此处先写三个循环
普通for循环:
格式:
① ② ③
for(循环初始语句;循环条件语句 ;改变控制循环变量语句 ) { //这个循环的作用是: 打印0-9之间的数字
④
System.out.println(i); //这是循环体
}
① ② ③
for(int i=0; i<次数; i++) { //这个循环的作用是: 打印0-9之间的数字
④
System.out.println(i); //这是循环体
}
执行顺序:
第一次: ①, ②, ④, ③
第二次: ②, ④, ③
第三次: ②, ④, ③
......
最后一次: ② //条件满足就执行循环体,不满足就结束循环
增强for循环;
for(数据类型 变量名 : 要遍历的集合或者数组) {
//正常的功能代码
}
集合的遍历:
HashMap集合的遍历:
// 增强for循环
// 1.获取所有键的集合 单列集合
// 2.遍历所有键的集合 获取每一个键
// 3.根据获取到的键去取值
1.继承
概述:在开发中,我们发现多个类具有很多相似的功能,于是我们就把这些相似的功能放到一个类中,然后让这多个类和这个类产生一个关系,
这个关系就叫做继承
关键字: extends
语法:
public class A类 extends B类{
}
认识:
A类: 子类,派生类
B类: 父类,基类,超类
特点:
1.子类继承父类,只能单继承,不能多继承,但是可以多层继承
2.子类继承父类,就拥有父类里面的非私有属性\方法
继承中成员变量的访问特点:
使用变量遵循"就近原则", 先在局部位置找, 有就使用, 没有就去本类的成员位置找,?
???? ?* 有就使用, 没有就去父类的成员位置找,有就使用, 没有就报错.
注意事项:
* 1.子类继承父类,不能继承父类的私有属性和私有方法
* 2.子类继承父类,不能继承父类的构造方法,但是可以使用
* 关键字: super
* 调用父类的空参构造方法: super();
* 调用父类的有参构造方法: super(参数);
*
* 直接调用父类的普通方法; super.方法名();
* 直接访问父类的属性: super.属性名
* 3.不要为了继承而继承
* Dog 属性:姓名 年龄
* 方法: 吃东西
*
* Person 属性: 姓名 年龄
* 方法: 吃东西
*
* 程序员:
* 属性: 姓名 工号 薪资
* 方法; 写代码
*
* 项目经理:
* 属性:姓名 工号 薪资 奖金
* 方法: 写代码 审计代码
* 4. 满足 is a 的关系
* 学生 属于 人类
* 子类 属于 父类
方法的重写:
概述: 子类出现和父类一模一样的方法
为什么要重写方法?
1.父类的功能无法满足子类的需求
2.当子类具有特有的功能的时候
重写的注意事项:
1.父类的私有方法不能重写
2.子类重写父类的方法,重写的方法的访问权限不能低于父类的访问权限
private(本类) < protected(同一个包) < 默认(本类和子类) < public(当前项目中)
3.静态方法严格意义上来讲不是方法的重写(只是表现形式和方法的重写意义)
方法的重载:
概述: 方法名一致,方法的参数不一致(参数的数据类型不一致,参数的个数不一致)
final 关键字
1.修饰类
被final修饰的类不能被子类继承
2. 修饰方法
被fianl修饰的方法不能被子类重写
3. 修饰变量
被final修饰的变量会变成一个常量,常量只能赋值一次
2. 多态
多态指的是: 同一种行为,对于不同的事物具有不同的表现形式。 这就叫做多态。
医生 咔 动手术
理发师 咔 剪头发
演员 咔 停止了
程序中的多态:不同的对象 以 自己的方式响应 相同名称方法的能力称为多态
Dog 吃 吃骨头
Cat 吃 鱼
Monkey 吃 香蕉
多态的条件:
1. 继承
2. 方法的重写
3. 父类的引用指向子类的对象
多态的使用\好处:
1. 开发中使用父类的类型作为方法的参数类型声明,那么以后不管传入任意的子类对象,都可以接收。
2.在调用方法的时候,调用的是子类的方法,前提是父类必须要有该方法,不然会编译不通过。
多态成员访问特点:
多态的成员访问特点:
成员变量: 编译看左边,运行看左边
成员方法:
静态方法: 编译看左边,运行看左边
非静态方法: 编译看左边,运行看右边
总结: 除了非静态方法是编译看左边,运行看右边,其他情况都是编译看左边,运行看左边
向下转型:
Animal anl = new Dog();// 向上转型
Dog dog = (Dog)animal;// 向下转型
dog.lookHome();
3.抽象类:
抽象方法: 没有方法体的方法就是抽象方法 一般用 abstract
抽象类: 用 abstract修饰的类就是抽象类, 有抽象方法的类一定是抽象类
特点:
1.有抽象方法的类一定是抽象类
2.不能创建对象,通过其子类来创建对象
3.可以有构造方法,但是不能用来创建对象,
用于子类对象访问父类数据之前,对父类的属性初始化
3.子类:
普通类: 必须要实现父类的抽象方法
抽象类: 不一定要实现父类的抽象方法
4.接口:
概述:用 Interface 定义的就是接口
实现:
public class 类A implements 接口{
}
public class 类A extends 类B implements 接口{
}
特点:
1. 定义接口 使用的关键字是 Interface
2. 实现接口 使用的关键字是 implements
3. 不能有构造方法,也不能创建对象,通过实现类来创建对象
4. 实现类:
普通类: 一定要实现接口中的抽象方法
抽象类: 不一定要实现接口中的抽象方法
成员特点:
JDK1.7及以前的:
成员变量: 默认修饰符 public static final
成员方法: 只能是抽象方法 默认修饰符 public abstract
JDK1.8:
成员变量:默认修饰符 public static final
成员方法: 增加了有方法体的方法,非静态方法,需要加 default 修饰,静态方法就直接写
接口:
类:
类和类的关系:
类和接口的关系:
接口和接口的关系:
接口和抽象类的区别: