第一章:Java环境搭建
Java是一种计算机编程语言;除了java编程语言, 还有很多的编程语言:c、c++、c#、python等 不同编程语言类比于不同国家语言;每个编程语言的 语法不同;应用场景不同 Java是一个用于后端开发的编程语言
一、Java历史
1. 1995年,sun公司推出的一款面向对象的编程语 言
2. jdk:java开发的必要工具
1997 jdk1.1
1998 jdk1.2
..
2004年: jdk1.5版本,更名为 jdk5.0 (添加新特性:泛型、增强的for等)
jdk6.0
jdk7.0
jdk8.0 -> 企业,lambda表达式 (stream流)
...
jdk18.0
....
2009年:sun被 oracle(甲骨文)收购了
java发展方向分为:【记住】
JavaSE:Java语言核心基础
JavaEE:企业级开发应用
JavaME:通信相关
二、Java语言的特点 【了解】
1. 简单性:相对 c、c++等
2. 开源性(开放源代码,编程人员写的程序)
3. 资源广泛性:很多编程爱好者进行研究,大厂作 为推手
4. 跨平台性:可以在不同的操作系统运行
windows、linux、unix、macos等
开发环境 windows /macos
部署环境:linux
5. 面向对象性:后续的讲解
三、Java运行机制
1. Java运行机制:先编译后解释运行
源码文件:.java文件,开发人员进行编写
编译:将 .java源文件通过编译器 生成对应的 字节码文件 (.class文件)
运行:将 .class文件 通过解释器-》逐行的翻译 并运行
2. 注意:实际运行时,运行 .class 文件;.java只需 要编译一次,.class文件可以被多次的运行(一次 编译多次运行)
注意:如果源代码更改,重新的编译,生成新的对 应的.class
Day2
四、环境搭建
1. 名词解释:
(1) JVM:Java虚拟机;作用:屏蔽不同操作系统 之间差异
(2) JRE: Java运行环境;JRE = 解释器+JVM
(3) JDK:Java开发工具,JDK=JRE+编译器+工 具类+工具
2. 安装JDK
点击 jdk的安装文件,按照 步骤完成即可
(1) jdk不要重复安装,如果想卸载,需要通过控 制面板
(2) jdk没有 提供操作界面,需要安装 notpad++ 文本编辑器进行编写代码
3. 配置环境变量
(1) java_home:jdk的根目录 C:\Program Files\Java\jdk1.8.0_131
(2) path:java的 bin目录 C:\Program Files\Java\jdk1.8.0_131\bin
(3) classPath:. ; 代表:告知jvm去哪找对 应的执行.class文件;. 代表在当前路径下查找
4. 测试jdk的安装是否成功
打开 Dos 命令窗口进行测试:
(1) 直接在 搜索框中输入 cmd按回车:
(2)直接 利用 先 系统键 + 同时 再按 R,输入 cmd即可
(3) 在 文件夹 的输入框中 输入 cmd,回车即可
在 窗口中 输入 :javac 和 java
五、Java的第一个开发程序
1. java的源文件以:.java进行结尾
2. class:类,代码容器
class 类名{
public static void main(String[ ] args){
}
}
(1) main函数:被称为 主函数,程序的入口,一 个类中最多只能有一个主函数
(2) System.out.println();// 控制台打印 输出信息
3. 编译和运行:
(1) 编译:javac 源文件名.java
(2) 运行:java 类名
4. 细节:
(1) 一个源文件中可以定义多个类,每个类中都可 以定义一个main函数
(2) 一个源文件中多个类之间不允许重名
5. 公开类:
(1) public:公开的、公共的
(2) 一个类被 public 修饰,则此类被称为公开 类、公共类
(3) 语法: public class 类名{}
(4) 公开类的类名必须和源文件名字一致
(5) 一个源文件中最多只能定义 一个公开类
六、package(包)
1. 作用:类似于文件夹,方便进行分门别类进行管理
2. 语法:package 包名;
3. 注意事项:
(1) package语句必须位于源文件中第一行有效语句
(2) 一个源文件中最多只能定义一个package语句
4. 带包的编译和运行
(1) 编译:javac -d . 源文件名.java
(2) 运行:java 包名.类名
七、编码规范
1. 良好的标识符命名规范
硬性规范(语法要求)
标识符:编码过程命名的内容
(1) java中标识符只能以 数字、字母、_(下划 线)、$;不能以数字开头
(2) java中标识符没有长度限制
(3) java中严格区分大小写
(4) 不能使用 java中的关键字、保留字(goto、 const)、特殊符号命名(true\false\null等)
注意:java中标识符命名可以使用汉字,但是不建 议使用汉字命
建议要求(软性要求)
(1) 望文生义,Student / Worker
(2) 包名:全小写, package demo.com.zmj;
(3) 类名:每个单词首字母大写,TestStudent
(4) 变量名/函数名/方法名:第一个单词首字母小 写,其余单词首字母大写(驼峰命名法) , ageAndName
(5) 常量:全大写; PI
Day3
2. 良好的编码格式
(1) 建议 一行只写一句代码
(2) 层级之间要有严格缩进,一个Tab键
3. 良好的注释习惯
注释:对代码的解释和说明
(1) // :单行注释:只能写一行注释内容
(2) /*
多行注释:可以写 N行注释内容
*/
注意:注释内容不参与编译
注意2:单行注释不能嵌套多行注释;
但是多行注释可以嵌套单行注释
第二章:变量、数据类型、运算符、表 达式
一、变量
1. 概念:计算机中的一块内存空间,存储数据的基 本单元
2. 变量的组成部分:数据类型、变量名、数据
3. 语法:
(1) 先声明,再赋值: 数据类型 变量名; // 声明 变量名 = 值; // 赋值
(2) 声明的同时并赋值: 数据类型 变量名 = 值;
(3) 同时定义多个相同类型的变量: 数据类型 变量名1,变量名2=值,变量3;
二、java中的数据类型分类
1. 简单数据类型、基本数据类型(原始数据)
B-Byte,字节,1个字节 = 8位(8b) b->bit
1KB= 1024B
1MB= 1024KB
1GB= 1024MB
1TB= 1024GB
..
10.24号,称之为 程序猿节
(1) 整数类型(4种)
byte 1B -128~127
short 2B -32768~32767
int 4B
-2147483648~2147483647
long 8B -922京 ~922京-1
注意:long的字面值后面需要加L或是l(建议大 写,区分数字1)
(2) 小数类型(浮点类型-2种)
float:单精度,4B,字面值后面必须加f/F
double:双精度,,8B,字面值后面可以加 D/d,或是不加
注意:float和double可以采用科学计数法进 行存储
(3) 字符类型(1种)
(4) 布尔类型(1种)
2. 对象数据类型、引用数据类型
(1) 类、数组、接口等都称为对象类型
(2) 以字符串为例:
a. 字符串:String
b. 使用 双引号引起来的 一个或是多个字符
String str = "hello";
数据类型实际开发总结:
整数类型通常使用:int
小数类型:double
布尔类型:通常应用判断、循环结构中
字符类型:实际开发不常用
字符串:实际开发频繁使用
实际存储数据:根据项目业务
姓名 :String name ="韩晨夕" ;
年龄 : int age = 35;
成绩 :double score = 99.5;
性别 :String sex = "男";
char c = '男';
int flag = 1;
// 1-男 0-女 电话: String tel= "17710131197";
地址: String addr = "天津市武清区";
身份证号: String id="37082819891012203x"
三、数据类型之间的转换
1. 自动类型提升
(1) 场景:小数据类型赋值给大数据类型(存储的 数据范围衡量数据的大小)
(2) 规则: byte->short->int->long->float- >double
char->int->long->float->double
2. 强制类型转换
(1) 场景:大数据类型赋值给小数据类型,需要强 制类型转化
(2) 语法:
源数据类型 变量名 = 值;
目标类型 变量名2 = (目标类型)变量名;
四、表达式
1. 理解:表达式由字面值、变量、运算符组成式 子,通常有一个结果
2. 表达式的结果规则:
(1) 如果表达式中有double类型,结果为double
(2) 表达式中没有double类型,有float,结果 为float
(3) 表达式中没有double/float,有long,结 果为long
(4) 其余结果为:int
五、运算符
1. 算术运算符
+ - *(乘法) /(除法) %(取余数/取 模)
注意:+ 的两种用法:
a. 如果+两端都为数值类型,则为加法运算
b. 如果+两端有一端为字符串类型,则为字 符串拼接
2. 赋值运算符
= += -= *= /=
3. 比较运算符(关系运算符)
> :大于
>=:大于等于
< :小于
<= :小于等于
== :等于
!= :不等于
注意:被关系运算符连接的表达式结果类型为布尔 类型,所以关系运算符连接的表达式也被称为 布尔 表达式(结果:true/false)
4. 逻辑运算符
&&:逻辑与,两端连接的为布尔表达式,只有当两 端同时为true,结果才true
||:逻辑或,两端连接的是布尔表达式,只要有一 端为true,结果为true
!:逻辑非,在结果上取反
5. 一元运算符:
++(自增) --(自减)
++(自增) --(自减)
a++ 和 ++a:将a自身变量值进行加1
a-- 和 --a:将a自身变量值进行减1
面试/考试常见内容:
int c = a++; 先使用,再加1
int c = ++a;先计算加1,再使用
6. 三元运算符
(1) 语法: 布尔表达式?表达式1:表达式2
(2) 原理:先判断表达式是否成立,结果为 true,执行表达式1,否则执行表达式2
六、Scanner(扫描仪)
1. 作用:可以让用户输入信息,提高人机交互
2. 导包:
(1) 语法:import 包名1.包名2.类名;// 导入 指定类
import 包名1.包名2.*;//导入包中 所有 类
(2) 位置:定义在package语句的后面,所有类上 面
(3) 例如:import java.util.Scanner;
3. 步骤:
(1) 导入包:
import java.util.Scanner;
import java.util.*;
(2) 创建对象:
Scanner sc = new
Scanner(System.in);
(3) 使用:
int n = sc.nextInt();//输入一个整数
double d = sc.nextDouble();//输入 一个小数
String s = sc.next();// 输入一个字 符串
char c = sc.next().charAt(0);//输 入一个字符
第三章:分支结构
一、if分支
1. 基本if结构:
(1) 语法:
if(判断条件/布尔表达式){
// 语句
}
(2) 执行原理:如果判断条件成立,则执行{}中的 语句
2. 基本if结构2
(1) 语法:
if(判断条件/布尔表达式){
// 语句1
}else{
// 语句2
}
(2) 执行原理:如果if条件成立,则执行语句1, 否则执行语句2
3. 多重的if结构
(1) 语法:
if(判断条件1){
// 语句1
}else if(判断条件2){
// 语句2
}else if(判断条件3){
// 语句3
}else{
// 语句n
}
(2) 执行原理:从上往下依次判断,哪一个条件成 立,则执行对应{}中的语句
4. if嵌套结构
(1) 语法:
if(判断条件/布尔表达式){
if(判断条件/布尔表达式){
//
}else if(判断条件){
}else{}
}else {
}
二、等值分支结构(switch...case结构)
1. 语法:
switch(表达式){
case 值1:语句1;break;
case 值2:语句2;break;
case 值3:语句3;break;
...
default:语句n;break;
}
2. 执行原理:
首先获取switch()中表达式的结果,根据结果从 上往下进行匹配case后面的值,结果和哪一个 case的值相等,则执行对应的后面的语句;如果都 不相等,则执行default后面的语句
3. 细节:
(1) 表达式的结果类型:byte、short、int、 char、String
(2) break:终止switch结构,防止case穿透
(3) default没有位置先后要求
三、局部变量
1. 概念:定义在函数/方法内部的变量
2. 特点:
(1) 必须先赋值,再使用 报错:可能尚未初始化变量
(2) 作用范围:从定义位置开始,到定义它的代码 块结束 报错信息为:找不到符号
(3) 在重合的作用范围内,不允许命名冲突 报错信息为:已在方法xxx中定义了变量 xx
第四章:循环结构
一、理解:
1. 循环:通过某个条件,重复并且有规律的执行一 段代码
2. 循环组成部分:循环变量的初始化、循环条件、 循环变量的改变、循环体
3. 循环分类:while循环、do..while循环、for循环
二、while循环
1. 语法:
// 循环变量的初始化
while(循环条件){
// 循环体
// 循环变量改变
}
2. 执行原理:
执行循环变量的初始化,接着判断循环条件,如 果循环条件满足——结果为true,则执行循环体,然 后执行循环变量的改变,接着再次判断循环条件, 如果满足——true,则再次执行循环体,同时循环变 量进行改变...直到循环条件不满足-结果为 false,则终止、跳出循环结构。
3. 循环特点:
(1) 先判断,再执行,执行次数:0~n次
(2) 如果程序写的不合适,可能会出现死循环
三、do..while循环
1. 语法:
// 循环变量的初始化
do{
// 循环体
// 循环变量的改变
}while(循环条件); // 分号不能省
2. 执行原理:
先执行循环变量的初始化,然后执行循环体,接着 对循环变量进行改变,判断循环条件,满足-结果为 true,则再次的执行循环体,对循环变量进行概 念,判断循环条件....直到循环条件结果为 false,结束、跳出循环结构。
3. 特地:先执行,再判断,执行次数为1~n次。
四、for循环
1. 语法:
for(循环变量的初始化;循环条件;循环变量的改 变){
// 循环体
}
2. 执行原理:
3. 执行特点:
(1) 先判断,再执行,执行次数 0~n次
(2) for()中的循环变量初始化可以定义在外面, 但是变量的作用范围扩大了
(3) for中的判断条件如果为空语句,则默认结果 为true
循环总结:
while和for:循环特点相同 先判断,再执行
do...while:先执行,再判断
实际开发:for循环比较常用
while循环:循环次数不明确时,建议使用while 循环
for循环:循环次数明确时,建议使用for
五、循环控制语句 【开发+面试+考试重点】
1. break:终止、结束当前循环结构;可以应用在 swtich..case结构中,防止case穿透
2. continue:中止、结束本次循环,从而进入下一 次循环
六、循环的嵌套
1. 理解:在循环结构中,定义一个完整的循环结构
外层循环和内层循环
2. 循环的次数:外层循环次数*内层循环次数
3. 循环控制语句应用的嵌套中:
break:终止、结束本层循环
continue:中止、结束本层本次循环
4. 利用循环结构打印图形:外层循环控制行数、内 层循环控制列数
第五章:函数
一、函数
1. 理解:执行一段特定功能的代码,并且可以通过 名字进行反复的调用
2. 函数的使用流程:
(1) 函数的定义:确定函数的功能和函数名
a. 函数的声明:确定函数的名字
b. 函数的实现:确定函数的功能
(2) 函数的调用:通过名字进行反复的使用
3. 函数的定义位置:定义类以内,其他函数以外的 位置(与main函数并列)
一、引出函数
在实现功能时,很多代码会重复出现,导致重复度高、开发效率低,将代码提取到一个函数中,需要的时候通过调用函数,从而实现写一次代码,可以多次调用的效c
二、函数概念
实现特定功能的一段代码,可反复使用
三、函数的定义
基本格式:
权限修饰符 静态修饰符 返回值数据类型 函数名(参数列表){
函数体;
return 返回的数据值;
}
说明:
- 权限修饰符 public
- 静态修饰符 static
- 返回值数据类型: 基本数据类型 引用数据类型 void(表示函数没有返回值)
- 函数名:命名规则和命名规范-见名之意 从第二个单词开始首字母大写
- 参数列表:函数可以没有参数 可以有一个参数 可以有多个参数数据类型 参数名,数据类型 参数名,....
- 函数体: 实现特定功能的代码块
- return 要返回的数据值;
如果返回值数据类型是void 则不允许通过return来返回数据值
如果指定了返回值数据类型 则return后的数据类型必须和指定的返回值类型匹配
函数定义的位置:
类里边 其他函数的外边
函数定义的顺序没有严格的要求
函数不调用不会执行 什么时候调用什么执行
调用函数:
如果函数没有返回值 没有参数
函数名();
如果函数有参数 则调用函数时需要传参
函数名(传递参数);
如果函数有返回值 则调用函数的同时需要获取返回值
数据类型 变量 = 函数名();
三、参数的使用
1. 多数情况下,函数与调用者之间需要数据的交 互;调用者必须提供必要的数据,才能使函数完 成相应的功能,调用者和函数之间交互的数据, 称为参数
2. 形式参数:
(1) 形式参数:简称形参,函数和调用者之间的一 种约定,约定了调用者需要给函数传递什么数据 (2) 定义: public static void 函数名(数据类型 变量名,数据类型 变量名,数据类型 变量名3){ }
(3) 使用:形参相当于 函数内部的局部变量
(4) 一个函数可以定义多个形参,称为形参列表 (0~n个)
3. 实际参数:
(1) 实际参数:简称实参,函数调用时,传递的数 据
(2) 实参的作用:给形参赋值
(3) 注意:实参的个数、顺序、数据类型必须和形 参一致 定义一个函数selectMax,接收两个整数m,n,打 印两个数据中的较大值;在main函数中调用此函数
四、函数的返回值
1. 理解:函数和调用者之间的一种数据交互,调用 者通过函数获取一些数据结果(函数给调用者一 定的结果)
2. 返回值的语法:
public static 函数返回值 函数名(形参列表)
{
// 函数的实现、函数体
}
3. 函数的返回值分类:
(1) 返回值类型为:void,代表函数没有返回 值,函数不需要给调用者任何结果返回
public static void 函数名(参数){}
(2) 返回值类型为:8种基本数据类型或是对象, 代表函数有返回值,函数必须给调用者返回值对应 类型的数据
public static 返回值类型 函数名(参数)
{
return xxx;
}
4. 函数返回值的处理:
(1) 第一种处理方式:定义同类型的变量接收返回 值
(2) 第二种处理方式:
5. return的作用:
(1) 将函数返回值进行返回值给调用者
(2) 结束当前的函数
五、函数的执行机制
1. 理解:
程序以Main函数作为入口,进入main函数从上往 下依次执行,如果遇到函数的调用,则优先执行被 调用的函数内部代码,被调用函数执完毕之后,带 着带着返回值返回到调用为止,继续后续代码内容
2. 函数的嵌套调用:被调用的函数内部,又调用了 其他的函数
六、递归调用
1. 理解:一个函数中调用自身函数
2. 注意:如果使用递归解决问题,必须给递归设置 一个出口,否则出现无穷递归,最终运行报错, 错误信息为: java.lang.StackOverflowError(栈溢出)
3. 递归的思想:
(1) 递进:每一次推进,计算都比上一次变得简 单,直至简单到无需继续推进,就能获得结果。也 叫到达出口。
(2) 回归:基于出口的结果,逐层向上回归,依次 计算每一层的结果,直至回归到最顶层。
4. 案例:
package demo;
public class Test6{
public static void main(String[] args){
int r =jieCheng(8);
System.out.println(r);
} // 函数功能:计算 n的阶乘
public static int jieCheng(int n)
{
// n的阶乘 = n * n-1 的阶乘
// 设置一个出口,当 n=1 或是0 , 结果直接为1
if(n==1 || n==0) return 1;
return n * jieCheng(n-1);
}
}
第六章:数组
一、理解
1. 数组:一次性的定义多个同类型的变量,可以存 储多个数据,而且可以对多个变量进行统一管理
2. 数组的重要因素:数据类型、数组的长度
3. 数组的使用:
(1) 声明数组:确定数据类型
数据类型[] 数组名; // 建议
数据类型 数组名[];
数据类型 []数组名;
int[] a;
(2) 分配空间:确定数组的长度
数组名= new 数据类型[长度];
a = new int[4];
4. 细节:
(1) 数组下标:从0开始,依次为 0、1、2、 3...数组的长度-1
(2) 访问数组时,采用数组名+下标,数组名[下 标]
(3) 操作数组时,给定的下标不在合理范围内,编 译通过,运行报错,错误信息为: java.lang.ArrayIndexOutOfBoundsExcept ion:(数组的下标越界)
(4) // 对数组元素进行一一 ,称为数组的遍历 for(int i=0;i对应的元 素
为:"+ages[i]);
}
(5) 获取数组的长度:数组名.length
5. 数组的默认值:
整数类型:0
小数类型:0.0
布尔类型:false
字符类型:空字符
引用类型:null
6. 数组 不同定义方式:
(1) 先声明,再分配空间:
数据类型[] 数组名;
数组名 = new 数据类型[长度];
(2) 声明的同时并分配空间:
数据类型[] 数组名 = new 数据类型[长 度];
(3) 显示初始化:
数据类型[] 数组名= new 数据类型[]{值 1,值2,值3};
(4) 显示初始化:
数据类型[] 数组名= {值1,值2,值3};
注意:数组的声明和初始化一起完成
二、数组的内存
1. 数组在内存中空间是连续的
2. 数组类型的变量,存储是数组内存在空间的首地 址
3. 寻址方式:首地址+下标*数据类型字节数
三、数组的扩容
1. 思想:
(1) 创建一个更大空间的新数组,通常为原数组的 2倍
(2) 将原数组的内容进行一一赋值到新的数组中
(3) 新地址覆盖旧
2. 扩容的实现:
(1) 第一种方式:
int[] a = {4,7,3}; // 数组的长度为
System.out.println("数组的长度 为:"+a.length);
for(int i=0;i
System.out.print(a[i]+" ");
}
System.out.println();
// 将数据 8 存储到 a数组中,不够 用,扩容
// 1. 创建一个更大长度的数组
int[] b = new
int[a.length*2];
// 2. 将原数组的内容一一赋值新数组中
for(int i=0;
//新的数组中 = 原数组中内容
b[i] = a[i];
}
// 3. 新的地址覆盖旧的地址
a = b;
System.out.println("扩容之后的 长度为:"+a.length);
for(int i=0;i
System.out.print(a[i]+" ");
}
(2) 第二种方式:借助工具类:
java.util.Arrays.copyOf(数组名,新数组的 长度);
四、二维数组
1. 二维数组:类似于excel表格,有行和列构成
2. 行标和列标都是从0开始,访问二维数组通过行 和列进行访问:数组名[ 行下标/高纬][列下标/低 维]
3. 二维数组的定义:数据类型[][] 数组名= new 数 据类型[行数][列数];
int[][] a= new int[4][3];// 4行3列二维 数组
五、数组的排序
1. 排序:将数组中元素按照一定的排序顺序进行存 储
2. 排序方式:从小到大
(1) 冒泡排序:每次将相邻的两个元素进行一一比 较,较大的值往后放
int[] a = {9,4,5,2,6,3,1,9};
/* 从小到大进行排序
冒泡排序:每次将相邻的两个元素进 行一一比较,较大的值往后
下标: 0 1 2 3
元素: 9 4 5 2
---------第一轮------------
a0~a1 4 9 5 2
a1~a2 4 5 9 2
a2~a3 4 5 2 9(最大 值)
----------第二轮-----------
a0~a1 4 5 2 9
a1~a2 4 2 5 9
---------第三轮-----------
a0~a1 2 4 5 9
*/
// 第 i=1 轮:使用 a[j]代表第一个 比较项,相邻 的一项 a[j+1]
/*for(int j=0;j
使用 a[j] 和 a[j+1] 进 行比较
if(a[j] > a[j+1]){
// 交换:借助第三遍历
int temp = a[j];
a[j] = a[j+1];
a[j+1] = temp;
}
}
// 第i=2抡:
for(int j=0;
使用 a[j] 和 a[j+1]进行 比较
if(a[j] > a[j+1]){
// 交换:借助第三遍历
int temp = a[j];
a[j] = a[j+1];
a[j+1] = temp;
}
}
// 第i=3抡
for(int j=0;
使用 a[j] 和 a[j+1]进行 比较
if(a[j] > a[j+1]){
// 交换:借助第三遍历
int temp = a[j];
a[j] = a[j+1];
a[j+1] = temp;
}
}*/
// 外层循环控制比较的轮数
for(int i=1;
内层循环,控制每一轮具体比 较的内容
for(int j=0;j< a.lengthi;j++){
// 使用 a[j] 和 a[j+1] 进行比较
if(a[j] > a[j+1]){
// 交换:借助第三遍 历
int temp = a[j];
a[j] = a[j+1];
a[j+1] = temp;
}
}
}
for(int i=0;i
System.out.print(a[i]+"\t");
}
(2) 第二种:借助工具类
java.util.Arrays.sort(数组名);
第七章:面向对象
一、编程思想
1. 面向过程
(1) 面向过程:将问题分为第一步、第二步、第三 步...直到问题解决
(2) 问题:解决小业务相对比较简单,但是面对复 杂业务时,相对不好处理
2. 面向对象:
(1) 面向对象:将一些业务过程看成一个整体,利 用对象之间关系,解决问题
(2) 好处:解决业务复杂问题时,相对简单
二、对象
1. 对象:计算机中的对象:复杂的客观事物在Java 程序中的一种表现形式
2. 对象的组成部分:
(1) 对象的属性:代表对象有什么特征,对应静态 数据部分
(2) 对象的方法:代表对象能做什么,对应动态的 行为和功能
3. 类:
(1) 计算机中,使用类进行区分不同类别对象,用 于描述该类对象有哪些属性和哪些方法
(2) 类和对象的关系: 类是对象的模板 对象是类的实例 注意:一个类可以创建多个对象
三、类的组成
1. 类名:望文生义,每个单词首字母大写
2. 类的组成:
class 类名{
// 1. 属性
// 2. 方法
}
3. 属性:
(1) 属性:也称为成员变量
(2) 位置:定义类以内,方法以外
(3) 语法:数据类型 变量名;
数据类型 变量名 = 值;
(4) 成员变量具有默认值:
整数类型:0
小数类型:0.0
布尔类型:false
字符类型:空字符
对象类型:null
(5) 成员变量的作用范围:至少在本类中有效
(6) 一个类中不允许成员变量命名相同,但是成员 变量可以和局部变量命名冲突;局部变量在方法中 被优先使用
4. 方法:
(1) 方法:也称为成员方法
(2) 位置:定义在类以内,其他的方法以外
(3) 语法:
public 返回值类型 方法名(形参){
// 方法体
}
(4) 方法的定义分为方法的声明和方法实现:
a. 方法的声明:
修饰符 返回值类型 方法名(形参)异常
注意:一个方法的修饰符可以有0~n个
b. 方法的实现:{}
5. 创建对象:
(1) 类名 对象名 = new 类名();
(2) 使用:
对象名.属性名
对象名.方法名(实参);
四、方法的重载(overload)【开发+面试+考试】
1. 理解:一个类中可以定义多个同名的方法,但是 参数列表不同
2. 要求:
(1) 方法名相同
(2) 形参列表不同(数据类型、个数、顺序)
(3) 返回值类型、修饰符、异常没有要求
3. 使用:根据调用时,传递的实际参数决定调用哪 一个方法
五、构造方法
1. 构造方法:是一种特殊的方法,也被称为构造器
2. 定义位置:定义类以内,方法以外
3. 特点(要求)
(1) 构造方法的方法名必须和类名一致
(2) 构造方法没有返回值类型(连 void 都没有)
(3) 语法:
修饰符 类名(形参){}
(4) 构造方法允许重载
(一个类中可以定义多个构造方法,但是无参 数的构造方法只能一个,可以同时定义多个有参数 的构造方法)
(5) 构造方法不能手动调用,在创建对象时,被调 用
4. 使用:
(1) 在创建对象时,根据传递的实际参数,决定具 体调用哪一个构造方法完成对象的创建
(2) 如果一个类中没有提供任何的构造方法时, jvm默认提供一个公开的无参数的构造方法;当类 中提供了有参数的构造方法,则默认的构造方法不 再提供(可以自定义写出)
5. 构造方法的作用:
(1) 用于创建对象
(2) 借助构造方法给属性赋值
6. 开发应用技巧:
实际开发一个类中通常提供两个构造方法:
(1) 一个无参数的构造方法
(2) 一个有参数的构造方法(参数取决于属性的个 数、类型、顺序)
六、this的应用
1. this.
(1) this代表当前对象,用于调用本类中属性或 是方法
(2) this.属性名
this.方法名(实参);
(3) this.通常可以省略,但是当成员变量和局部 变量命名冲突时,可以使用 this. 区分成员变 量
2. this()
(1) this()只能应用在构造方法中,调用本类其 他构造方法
(2) this()只能应用在构造方法中的第一行有效 语句
七、引用
1. 引用:对象类型的变量
java 是一种强类型的语言,对应类型的数据需要 存储在对应类型的变量中:
类名 引用名 = new 类名(实参);
// 引用 对象
// 引用类型 对象的类型
注意:引用的类型必须和对象的类型一致
2. 引用存储对象在堆空间中首地址
3. 每个对象在堆空间是相互独立,操作一个对象不 会影响其他对象
4. 可以单独的声明引用: 类名 引用名;
5. 相同类型的引用之间可以相互赋值,传递的是对 象在堆空间中首地址
6. 可以利用null作为引用的初始化数据,代表空地 址,但是如果使用存储null引用调用属性或是方 法,编译通过,但是运行报错,错误信息为: java.lang.NullPointerException(空指针异常)
7. 引用的应用场景:
(1) 引用应用在形式参数上:该类型的对象和引用 都可以作为实际参数进行传递
(2) 引用应用在返回值类型上:该类型的对象或是 引用都可以作为返回值进行返回
第八章:面向对象的三大特性(封装、继 承、多态)
一、封装
1. 目前的程序无法保证数据的安全性、容易造成业 务数据的错误
2. private:私有的,被private修饰的内容只能在 本类中访问
3. 为私有化的属性提供公开的get和set方法:
(1) get方法,获取私有化属性的值:
public 返回值类型 get属性名(){
return 属性名;
}
注意:返回值类型取决于获取属性的类型
方法名:get+属性名首字母大写
(2) set方法,为私有化属性赋值:
public void set属性名(数据类型 变量 名){
this.属性名 = 变量名
}
注意:()中的数据类型取决于属性类型
方法名:set+属性名首字母大写
二、继承
碳素笔 是一种 笔
水杯 是一种 容器
狗 是一种 动物
A is a B
如果 A is-a B 关系成立,A和B之间具有继承关系
A-子类 继承 B-父类
extends
1. 理解:
(1) 继承体现的是类之间的一种“is-a”关系。
A is a B
子类 父类
子类 继承 父类
extends
(2) 语法:
class 子类类名 extends 父类类名{}
(3) 通过继承关系,子类型可以直接使用父类中定 义的属性和方法
2. 继承体现了程序的复用性和可扩展性
3. 方法的覆盖【也被称为方法的重写 - override】
(1) 方法的覆盖:子类中定义和父类中相同的方法
(2) 方法的覆盖要求:
a. 子类的方法名、形参列表、返回值类型必须和 父类一致
b. 子类的访问修饰符,和父类相同或是比父类更 宽
(3) 如果子类覆盖了父类中方法,则优先使用子类 覆盖后的
(4) 注意:如果子类定义了和父类方法名、形参列 表相同,但是返回值类型不同的方法,则编译报错
(5) 如果子类定义了和父类方法名相同、形参列表 不同的方法,则编译通过,运行也ok,这构成了方 法的重载
4. Java中继承特点:
(1) 一个父类可以有多个直接的子类
class Animal{}
class Dog extends Animal{}
class Cat extends Animal{}
(2) 一个子类只能有一个直接的父类,但是可以有 多个间接的父类(多级继承),java中的类之间是单 继承
5. java中的访问修饰符:
(1) 访问修饰符代表一种访问权限
(2) java中有4个访问修饰符:
private:私有的
default:默认的
protected:受保护的
public:公开的
(3) 访问修饰符的访问权限:
本类 同包 非同包的子类
其他
private ok
default ok ok
protected ok ok ok
public: ok ok ok ok
(4) 访问修饰符修饰内容的继承性:
private 修饰的属性和方法,不能被继承
default 修饰的属性和方法,同包子类允许 继承
protected 修饰的属性和方法,同包+非同 包子类继承
public 修饰的属性和方法,所有子类都可以 继承
6. super的应用:
(1) 第一种用法:super.
a. super.引用在子类的方法中,代表访问 父类中属性或是成员方法
b. super.属性名
super.成员方法名(实参);
(2) 第二种用法:super()
a. 创建子类对象时,jvm默认创建一个父类 对象,而且默认使用父类中无参数的构造方法完成 父类对象的创建
b. super()/super(实参):应用在子类的 构造方法的第一行有效语句中,代表创建子类对象 时,告知jvm完成父类对象创建时采用哪一个构造 方法完成对象的创建
c. 如果子类的构造方法第一行没有指定 super()/super(实参),则默认添加super()
三、多态
1. 理解:
(1) 多态:父类型的引用存储不同子类型的对象
父类类名 引用名 = new 子类类名 ();
引用 对象
父类型 子类型
(2) 使用父类型的引用调用属性或是方法,只能调 用父类中定义的属性和方法
(3) 如果子类覆盖了父类中方法,则优先使用子类 覆盖后的方法
2. 引用之间的转换:
(1) 父类型的引用赋值给子类型的引用,需要强制 类型转换
大类型 小类型
a. 子类类名 引用名 = (子类类名)父类型 的引用名;
b. 强制类型转换的结果:
i. 实际存储的对象类型和要转换类型一 致,编译+运行通过
ii. 实际存储的对象类型和要转换的类型 不一致,编译通过,运行报错,错误信息为:
java.lang.ClassCastException(类型转换异 常)
(2) 子类型的引用 赋值给父类型的引用,无需强 转,直接赋值,体现多态
(3) 没有继承关系双方,不允许相互赋值,强制类 型转换也不允许
3. instanceof避免类型转换异常:
(1) 语法:引用名 instanceof 类名
(2) 执行:判断引用中存储的实际对象类型是否兼 容于后面的类型(是否为后面类型的一种),兼容true,不兼容-false
(3) 作用:可以在程序设计中避免类型转换异常
直接使用案例中的 Animal、Dog、Cat类即可, 在main函数中完成以下功能:
public static void main(String[] arsg){
Animal a = null;
/*
利用Scanner输入一个整数n,n是偶数 则存储Dog,
否则存储Cat
*/
/*
判断:如果a中存储的是Cat,打印输 出"我是猫" ,
否则打印输出"我不是猫"
*/
}
4. 多态的应用:
(1) 多态应用在形式参数上:本类型+所有的子类 型对象、引用都可以作为实际参数进行传递
(2) 多态应用在返回值上:本类型+所有子类型的 对象、引用都可以作为返回值进行返回
第九章:三个修饰符
一、abstract[抽象的]
1. abstract可以修饰类:
(1) 被abstract修饰的类称为抽象类
(2) 语法: abstract class 类名{}
(3) 特点:抽象类只能声明引用,不能创建对象
(4) 抽象类中可以定义属性和成员方法、构造方法
2. asbtract可以修饰方法:
(1) 被asbtract修饰的方法称为抽象方法
(2) 语法: 访问修饰符 abstract 返回值类型 方法名 (形参); 注意:访问修饰符和abstract没有先后顺序
(3) 特点:抽象方法只有声明部分,没有方法的实 现
(4) 注意:抽象方法只能定义在抽象类中
3. 抽象可以定义子类
(1) 语法:class 类名 extends 抽象类类名{}
(2) 特点:子类不想成为抽象类,则必须覆盖父类 中所有的抽象方法
二、static[静态的]
1. 可以修饰属性:
(1) 被static修饰的属性称为静态属性、静态变 量、类变量
(2) 语法:
static 数据类型 变量名;
static 数据类型 变量名 = 值;
(3) 特点:静态变量基于类存在,被所有对象共 享,和创建对象的多少无关
(4) 使用:
a. 可以通过 对象.静态属性名
b. 可以直接通过 类名.静态属性名 ->建 议
2. 可以修饰方法:
(1) 被static修饰的方法称为静态方法
(2) 语法:
访问修饰符 static 返回值类型 方法名(形 参){}
(3) 使用:直接通过 类名.静态方法名(实参);
(4) 注意:静态方法中只能访问本类的静态成员, 不能直接访问本类的非静态成员
(5) 静态方法中不能使用 this 和 super关键字
3. 可以代码块
(1) 被static修饰的代码称为静态代码块
(2) 位置:定义在类以内,方法以外,被 static 修饰的{}
(3) 语法:
class 类名{
static{}
}
(4) 作用:在类加载的时候,静态代码块按照和属 性定义的先后顺序完成对静态属性的初始化工作 (5) 类加载:当jvm第一次使用一个类的时候,通 过classpath找到类对应的.class文件,对文件 进行读取,读取该类的包名、类名、父类、属性、构 造方法等信息,并将读取的信息保存到jvm内存 中,一个类进行一次类加载。
(6) jvm类加载的时机(什么叫第一次使用一个 类):
a. 第一次访问该类的静态成员
b. 第一次创建该类对象: 先进行类加载,再完成对象的创建
c. 子类类加载,先导致其父类类加载
三、final[最终的、最后的]
1. final可以修饰变量:
(1) 被final修饰的变量作用范围内的常量
(2) final 数据类型 变量名;
(3) 特点:只允许一次赋值,不允许修改
(4) 注意:引用一旦被final修饰,代表引用中存 储的对象不能更换
2. final可以修饰方法:允许子类继承,但是不允许 覆盖
3. final可以修饰类:被final修饰的类不允许被继 承,没有子类,例如:System、Math
思考:
System.out.println(); 实现原理?
System -> 类
out -> 静态 属性 -》对象类型
println() -> 方法