Dos命令
打开Dos快捷键：windows+R
输入：cmd
开启快速复制：鼠标右键>属性>编辑选项
cd
切换目录
cd..
返回上层目录
cd\
退回当前目录
dir
查看当前目录子文件和子文件夹
cls
清屏
exit
退出
Tab
自动补全
↕
使用用过的命令
mkdir
创建
rmdir
删除
jdk新特性
jdk1.2
JVM
数据类型敏感
结构分离
Java2 被划分为J2SE J2EE J2ME
jdk1.5
自动装箱与拆箱
自动装箱的过程
每当需要一种类型的对象时，这种基本类型就自动地封装到与它相同类型的包装中
自动拆箱的过程
每当需要一个值时，被装箱对象中的值就被自动地提取出来，没必要再去调用intValue()和doubleValue()方法
自动装箱
只需将该值赋给一个类型包装器引用，java会自动创建一个对象
自动拆箱
只需将该对象值赋给一个基本类型即可
java——类的包装器
类型包装器有：Double,Float,Long,Integer,Short,Character和Boolean
枚举
简单的用法
JavaEnum简单的用法一般用于代表一组常用常量，可用来代表一类相同类型的常量值
复杂用法
Java为枚举类型提供了一些内置的方法，同事枚举常量还可以有自己的方法。可以很方便的遍历枚举对象
静态导入
通过使用 import static，就可以不用指定 Constants 类名而直接使用静态成员，包括静态方法
jdk1.7
switch中可以使用字串
Boolean类型反转，空指针安全,参与位运算
安全的加减乘除
jdk1.8
允许在接口中有默认方法实现
函数式接口
方法和构造函数引用
jdk安装
jdk和jre安装同一路径
测试是否成功：java -version
java小程序详解
public<公共的> class<类> name<类名><首字母大写>{<类体的开始><一对{}就要缩进(Tab)>
public<公共的> static<静态的> void<没有返回值的> main<主方法><程序的入口>(String[] args<参数列表>){<方法体的开始>
System<系统>.out<输出>.println<打印>("Hello");<""里原封不动的输出>
}<方法体的结束>
}类体的结束
类(Class)
一个文件中可以有多个类,但只能有一个类被public修饰,并且这个类名要与文件名一致
方法(Method)
一个类中可以存在多个方法,但是只能有一个主方法,主方法是程序的入口,逐行执行主方法中的代码
一个类中可以没有主方法,但是如果解释执行一个类,没有主方法会报错
注释(Comment)
什么是注释?
解释说明文字
为什么使用注释?
对程序的说明
便于后期维护
单行注释
作用域:只在当前行有效
嵌套:可以嵌套单行注释,不可以嵌套多行注释和文档注释
颜色:绿色
位置:行的上面或者行的末尾
多行注释
作用域:多行有效
嵌套:可以嵌套单行注释,不可以嵌套多行注释和文档注释
颜色:绿色
位置:类的上面或方法的上面
文档注释
作用域:多行有效
嵌套:可以嵌套单行注释,不可以嵌套多行注释和文档注释
颜色:墨蓝色
位置:类的上面或方法的上面
可以出现在类的API文档中,生成某个类的api文档,javadoc
注释的内容不会被编译(可以通过反编译工具验证)
标识符(Identifier)
在java中一切起名字的地方的名字就是标识符
命名规则
标识符只能数字,字母,下划线_,美元符号$任意组合而成,但是数字不能开头
标识符严格区分大小写
关键字不能作为标识符使用
命名规范
见名知意
驼峰命名原则
包: 全部小写
单级包: shangxuetang
多级包: shang.xue.tang
类|接口
每个单词的首字母大写 ShangXueTang
方法|变量
第一个单词全部小写,第二个单词开始,每个单词首字母大写 shangXueTang
常量
全部大写 每个单词之间使用_进行分割 SHANG_XUE_TANG
关键字
在java中,有一些词有自己的用法或者用途,这些词就是关键字
所有的关键字都是小写,颜色存在不同显示
保留字
在java中,有一些词将来有可能有自己的用法或者用途,这些词就是保留字
goto
const
常量(Constant)
在程序执行过程中，其值不会发生改变的量
分类
字面值常量
整数常量： 123 -123
小数常量： 1.2 -1.2
字符串常量： "abc"
字符常量： 'a'
布尔常量： true，false
空常量： null
自定义常量
final修饰的变量为常量
知识扩展
(println)ln是光标从这一行的行位换到下一行的行首
变量(Variable)
可变的量
在java程序执行过程中,其值会发生改变的量
在内存中,开辟一块空间,用来存放指定数据类型的数据
语法
声明的同时赋值
数据类型 变量名 = 变量值;
int a=10;
先声明后赋值
数据类型 变量名;
String name;
变量名= 变量值;
name="张三";
一行同时声明多个变量
int x,y,z;
= 是java中唯一一个自右向左运算的符号
z=x=y=10;
变量名字 (遵循标识符的命名规则和规范)
变量的值 (和数据类型一致)
作用域: {}
在其作用域范围内才能使用,变量同一时只能指向一个值
同一作用域中的变量不能同名
分类
局部变量
方法|语句块内定义的变量
使用前必须声明并且已赋值
成员变量|实例变量
类中方法外
如果成员变量只声明未赋值,存在默认值
byte,short,int,long-->0
float,double-->0.0
char-->\u0000
boolean-->false
String-->null
数据类型(DataType)
基本数据类型
byte(字节型)
1个字节 8位
[-128,127]
short(短整型)
2个字节 16位
[-32768,32767]
int(整型)
4个字节 32位
[-2147483648——2147483647]
long(长整型)
8个字节 64位
[-9223372036854775808~9223372036854775807]
float(单精度)
4个字节
精度为6~7位有效数字
double(双精度)
8个字节
double的精度为15~16位
char(字符型)
2个字节
0~65535
boolean(布尔型)
1位
true
false
String(字符串)
整数的字面长量值默认的数据类型是int类型
如果给byte,short赋值,只要在其范围之内的字面常量值都能成功赋值
如果想要给long类型的常量赋值,需要在数据的后面添加一个L/l 推荐使用L
小数默认字面常量值类型为double,如果想要给float赋值,在数据的后面添加一个f/F
小数因为内部存储方式的不同,运算不精确的
如果字符型的数据参与运算,默认转为十进制的数再去运算
引用数据类型
类(class)
接口(interface)
数组[](array)
数据类型转换(DataTypeConvert)
boolean类型不参与类型转换
自动类型提升:隐式类型转换
从小范围类型->大范围的数据类型
byte b1=127;
short s1=b1;
强制类型转换:显示类型转换
从大范围类型->小范围类型,有可能会损失精度
float f1=(float)1.9;
int int1=(int)f1;
小范围数据类型 变量名 = (小范围数据类型)大范围数据类型;
byte by1=(byte)128
转义字符(EscapeCharacter)
用来表示有些具有特殊含义的字符
转义字符从\开始
\t 制表符
一个制表符代表8个空格,一个字母1个空格,一个汉字占2个空格
查看前面的内容,是否满足制表符的整数倍,如果不满足补满,如果满足重开一个制表符位
\b退格
光标会删一格
\n换行
ln类似
\r 回到行首
光标回到行首
数值形式(Numerical)
整数的不同进制:满几进一
二进制: 由0,1组成 以0b/0B开头表示二进制
八进制: 由0~7组成 以0开头表示八进制
十进制: 默认
十六进制: 0~9,a~f组成 大小写都可以 以0x/0X表示十六进制
其他进制转十进制:从后往前,从最后一位开始*进制数,次方从0开始每次+1,最终所有位数的值求和
十进制转其他进制:一直除以要转为的进制数,得数为0为止
浮点数的表示形式
0.5->0可以省略
科学计数法表示
e->10
1.234e2 ->1.234*10^2
1.234e-2 ->1.234/10^2
运算符(Operator)
操作数: 运算符左右两边的数叫做操作数
表达式: 运算符链接两边的操作数咋横踢叫做表达式
语句: 遇到;就是语句的结束
单目运算符|一元运算符
操作数只有一个 ++ -- -负号
双目运算符|二元运算符
+ - / * %
三目运算符|三元运算符
条件运算符
算数运算符
+
+正号
加法运算
字符串的连接符
当+左右两边由字符串的出现,就作为字符串的连接符使用,最终得到一个字符串结果
-
负号 不能省略
减法运算
*
乘号
乘法运算
%
取余数|取模|模以
如果前面的操作数<后面的操作数,结果为第一个操作数
++ --
操作自己|不影响别人
++放在操作数的前面还是后面都是自身+1
--放在操作数的前面还是后面都是自身-1
操作别人|影响别人|参与运算
++--放在操作数的前面,先自身先去+1|-1,再参与运算
++--放在操作数的后面,先参与运算,再自身+1|-1
赋值运算符
基本赋值运算符
=
java中唯一一个自右向左运算的符号
优先级别最低
扩展赋值运算符
算数运算符+基本赋值运算符
+= -= *= /= %=
优点: 自动做强制类型转换 ,提高执行效率
缺点: 不直观
关系运算符|比较运算符
> < >= <=
只能针对byte,short,int,long,char,float,dobule进行比较
== !=
可以对基本数据类型或引用数据类型做比较
比较运算符最终的结果都是boolean类型的值 true,false
逻辑运算符
逻辑运算符左右两边的操作数都是值为boolean类型的表达式
& 与 一个为false就是false,两个都是true才是true
| 或 一个为ture就是true,两个都为false才是false
^ 亦或 相同为false,不同为true
&& || 短路,如果第一个值已经能够决定表达式的结果,第二个值就不再执行
条件运算符
条件表达式 ? 值1 : 值2;
条件表达式是值为boolean类型的表达式
执行流程
计算条件表达式
如果值true,最终结果取值1
如果值false,最终结果取值2
位运算符
先把操作数转为二进制,参与运算,结果转为10进制
& 统一位数的两个数,如果一个为0就是0,两个都为1才是1
| 同一位数的两个数,如果一个为1就是1,两个都为0才是0
^ 相同为0,不同为1
右移运算符 相当于/2的第二个操作数次方
>> 假设第一个操作数二进制数的右边有一个分水岭,移动第二个操作数个位数,移出分水岭的数不计算,剩下的二进制转为十进制
左移运算符 相当于*2的第二个操作数次方
<< 向左移动第二个操作数个位数,空余补0,最终转为十进制
Scanner ( 接受键盘输入)
导包
说明Scanner类的地址 使用import关键字+路径 导包 java.util.Scanner;
导包要类的上面导包
创建Scanner类型的变量--根据公式 Scanner sc=new Scanner();
使用功能
nextInt() 接受int类型的整数
nextByte() 接收byte类型的整数
nextShort() 接收short类型的整数
nextLong() 接收long类型的整数
nextDouble()
nextFloat()
next() 接收用户输入的字符串类型的数据
从有效字符开始接收,知道遇到空格,tab不再接收了,enter停止功能
nextLine() 接收字符串数据,遇到enter结束功能(接收一整行)
关闭
变量.close();
一定要再这个类使用完毕Scanner之后再关闭,否则后面重新开启也无法继续使用
Random(产生随机数)
导包 java.util.Random
创建Random类型的变量|引用
通过引用数据功能
随机整数
nextInt() 随机产生int类型范围内的一个随机整数
nextInt(整数n) 范围: [0,n)随机整数
公式
[min,max) 引用.nextInt(max-min)+min
[min,max] 引用.nextInt(max-min+1)+min
随机小数
nextDouble() 产生随机小数 [0,1)
流程控制语句(If)
顺序结构
选择结构:根据判断,满足条件执行某些代码
循环结构:重复执行某些代码
if..else
单分支|单选泽
if(条件判断){
满足条件要执行的语句
}
执行流程
计算判断条件(值为boolean类型的表达式)
如果true,执行{}语句体
如果false,不执行,直接跳过if结构
双分支|双选择
if(条件判断){
语句体1;
}else{
语句体2;
}
无论是否满足都会有与具体执行,肯定会有一个结果
多分支|多选择
同是双分支
if和条件表达式之间的区别
if可以对多个条件多次判断
条件表示肯定会有结构
Switch
语句 定值判断
语法
switch(表达式){
case 值1:
语句体1;
break;
case 值2:
语句体2;
break;
default:
语句体n;
break;
}
表达式:byte,short,int,char,1.5新增枚举,1.7新增字符串
可以是常量(没有意义),变量,表达式
case
表达式的结果与case后面跟的值进行判断,如果相同就执行对应的case后面的语句体
break
停止|结束|终止 switch语句,没有break会发生case穿透
default
相当于else,如果以上都不满足条件,执行default中的语句,可以放在switch中的任意位置,一般放再最后,放在最后break可以省略
执行流程
计算表达式的结果
拿表达式的结果与case后面的值依次比对,如果遇到相同的值,就执行对应的语句体,然后遇到break结束,如果没有break会发生case穿透
if和switch之间的区别
if可以做区间判断,可以做定值判断
switch语句只能做定值判断
For
重复执行某段代码
for循环
for(条件初始化;条件判断;条件变化){
循环体语句;
}
条件初始化
声明一个变量并且赋值 条件-->变量
条件判断
判断上面的条件是满足指定的要求
条件变化
条件自身值的改变 ,如果没有条件变化,将会变成死循环(永远不会停止的循环)
执行流程:
执行流程
条件初始化
条件判断,判断结果如果为false,不会执行语句体,for结构直接结束,如果为true,满足条件,执行循环体语句
条件变化
Math.random() 产生随机数
随机数范围[0,1)随机小数
产生[min,max) 随机整数 (int)(Math.random()*(max-min)+min)
产生[min,max] 随机整数 (int)(Math.random()*(max-min+1)+min)
Math.round(参数) 四舍五入 针对小数点后一位四舍五入
Math.sqrt(参数) 平方根
while循环
基础结构
while(条件判断){
循环体语句;
}
do...while()
语法
条件初始化;
do{
循环体语句;
条件变化;
}while(判断条件);
无论是否满足条件,都至少执行一次
执行流程
.条件初始化
执行循环体语句
条件变化
判断条件是否满足,为true,进入到下一次循环.如果为false,dowhile循环结束
break和continue
break
应用场景: switch语句和循环中
作用:结束switch或者结束循环作用
continue
应用场景:只能用在循环中
作用: 结束本次循环直接进入到下一次循环
循环嵌套
for(条件初始化;条件判断;条件变化){
//代码
for(条件初始化;条件判断;条件变化){
//代码
}
//代码
}
方法
实现具体功能的代码段
使用方法好处
提高代码的复用性
语法
有返回值类型的方法
修饰符 返回值类型 方法名([参数列表]){
具有某些功能的代码块;
return 返回值;
}
修饰符:访问权限修饰符,public static默认,具体等到面向对象再说
返回值类型:方法运行后的结果的数据类型-->返回值类型的方法就是要得到这个返回值
方法名:方法的名字 ,根据方法名字调用方法
return
提前结束方法
带出返回值
有返回值类型的方法的调用
直接调用: 方法名();
赋值调用: 返回值类型 变量名= 方法名();
输出调用: System.out.println(方法名());
知识扩展
出现不可达语句的几种的情况
如果再一定会执行的return后面出现的语句
break后面
continue
死循环后面
while(false){...}
重载
在同一个类中,有多个方法,相同的方法名,不同的参数列表(方法签名不同: 方法名+参数列表 ->方法的唯一标识)
满足方法重载的几个条件
同一个类
多个方法,方法名相同
参数列表不同
如何决定调用重载方法中的哪个方法
由实参决定
方法的重载和方法的修饰符无关
方法的重载和方法有没有返回值类型无关
方法的重载和方法返回值类型无关
方法的重载和方法参数名无关
方法的重载是一个类中多态的一种体现
方法是一个类中封装的一种体现
递归
自己调用自己
临界条件
让递归停下来的条件
递归前进段
到临界条件之前一直自己调用自己
递归后退段
到达临界条件之后,把结果返回给上一层
面向对象
面向对象和面向过程之间的区别
面向对象和面向过程都是一种思想,一种思维方式
面向过程
" 我应该如何实现?"然后一步一步实现就可以了
面向对象
" 我应该找谁来完成?" 不关注对象如何实现,只关注对象
面向对象的优点
更贴合与现实生活
面向对象体现与管理者,面向过程体现与执行者
可以复杂的问题简单化
如何使用面向对象的思维方式进行编程
提供了两个概念实现面向对象编程: 类 对象
类:->自定义的类 一些列事物的模板,一些列事物抽象出来的共性,吧这些共性定义为自定义类|模板类
对象:现实生活中真实存在的事物,构建需要根据对象的图纸|模板类构建对象
自定义类
public class 类名{
//成员变量
修饰符 数据类型 变量名 =赋值;
//成员方法
public 返回值类型|void 方法名(参数列表){
...
}
}
构造器
特殊的方法，作用就是用来为对象初始化对象信息,不是用来创建对象
new做3件事情
堆中开辟空间,成员属性跟随对象进入堆内存并附默认值
调用构造器为对象初始化信息
将地址返回给引用
定义
修饰符 类名([参数列表]){
....
}
构造器没有返回值，不需要void，可以写return但是不必要
使用
只能跟随new一起使用,没有办法调用
构造器不能和static,fianl,abstract一起使用
如果没有自定义构造器,编译器会自动为你添加一个空构造
如果存在自定义构造器,编译器都不会再为你提供任何构造器
构造器也是方法,可以构造器的重载,根据创建对象后面的()-->构造器的参数列表
this关键字
this指代当前对象(new的对象),代表对象的地址
调用本类中的其他构造器
this([参数列表]);
要求再构造器的首行使用this调用其他构造器
两个构造器不能相互调用,会造成死循环
区分同名变量问题
区分成员变量和局部变量之间同名的问题
构造器中区分成员变量和参数之间同名问题.默认就近原则,如果调用成员,this.属性名,因为this中存放的是当前调用构造器的对象的地址
this再成员方法中指代当前调用成员方法的对象
如果不存同名变量问题,在使用成员变量的时候默认前面省略了this,this可以省略
static
static修饰变量->静态变量|类变量
static是成员修饰符,不能修饰局部
static修饰方法->静态方法|类方法
被static修饰的方法|变量使用方式
类名.静态变量名
类名.静态方法名
对象.静态变量名
对象.静态方法名
静态的内容是属于类的,成员的内容是都属于对象的,跟随对象使用
静态的变量会在类第一次加载时候加载,独有一份,当前类中所有对象共享的资源
在静态的内容中,可以直接使用静态的内容,不可以直接使用非静态的内容
再非静态的内容中,可以直接使用静态的内容,可以直接使用非静态的内容
block块
{} 就是一个作用域
{}->方法中|语句块中 --局部代码块|普通语句块
执行时机:跟随方法执行
{}->类中方法外 --构造块
执行时机:new对象
static{} ->类中方法外--静态块
执行时机:类第一次加载的时候
同步块-->多线程
构造块会在创建对象的时候,其中一步调用构造器,构造块会在构造器之前执行,
如果由多个构造块,从上倒下依次执行
静态块是静态的内容,会在类第一次加载的时候执行一次
执行顺序
静态块--main--构造块--构造器
debug调试
先打断点
debug模式运行
f5进入细节
f6下一步执行
f7返回方法的调用出
gc
System.gc()
通知垃圾回收机制回收垃圾
finalize()
如果gc回收垃圾第一步会调用finalize()方法
一定会调用finalize()方法的两种情况
匿名对象
对象无引用状态
程序员无权控制垃圾回收机制
import
不要定义与jdk相同的包，相同的类，否则会引起很多你觉得莫名其妙的问题
不需要使用import的类有
语言包 （java.lang）下的类
同包下的类
静态导入
导入类中的静态内容 import static..
模糊匹配
模糊匹配当前包下的所有的类
会降低编译速度,不会降低运行速度
封装
私有的 成员修饰符,不能修饰局部变量
私有的内容,只能在本类中使用
对的私有的内容提供公共访问方式 设置器 访问器
方法 setter getter
私有的属性,公共的访问方式真的安全了么???
不能直接操作属性
使用逻辑进行判断
面向对象的三大特性之一
面向对象的三大特性之一
私有是封装么???
私有肯定是封装
封装不一定只有私有
方法,类..都是封装的体现
好处
隐藏实现细节，提供公共的访问方式
提高代码的复用性
提高代码的安全性
javabean类:-->实体类|模板类|封装类
javaBean编码规则
javaBean必须声明为public class，这样才能够被外部所访问；
一个JavaBean中至少存在一个无参构造方法
类中所有的属性都必须封装，即：使用private声明；
为封装的私有属性提供公共的setter、getter方法；
继承
子承父业
为什么使用继承
为了达到类层面的复用
如何使用继承
子类 extends 父类
特点
子类一旦继承父类,就自用拥有了父类中的内容
一个类可以有多个子类,一个类只能有一个父类,单继承机制,多实现
子类是父类的延续+扩展
父类|基类|超类:-->被继承的类
子类|派生类:-->继承其他类的类
继承的优点
提高代码的复用性
单继承的优点: 使用简单
但继承的缺点: 不便于后期维护
面向对象设计原则之一:开闭原则 对修改关闭,对扩展开放
权限修饰符
private
本类
default(默认)
本类
同包类
protected
本类
同包类
不同包子类
protected的访问权限
同包下的类
不同包的子类,并且只能通过子父类关系访问,只有子类中才可以使用
public
本类
同包类
不同包子类
不同包下的其他类
以上权限修饰符只能修饰成员(static),成员修饰符(成员变量|成员方法)
private的内容不能被继承
只有public和default能修饰类,并且default默认出现
重写
重写和重载之间的区别
重写和重载都是指方法
不同的类
继承关系|实现关系
方法签名相同(方法名+参数列表)
如果存在方法的重写,再调用的时候调用的是子类中重写的方法
重写方法会对父类中被重写的方法进行屏蔽
如何检查方法的重写
左边会有一个向上的三角
强制检查 @Override
== : 方法签名
<= : 返回值类型 :
基本数据类型完全相同
引用数据类型:子类<=父类
>= : 权限修饰符:子类>=父类的权限修饰符
不能被重写
被private修饰的方法不能被重写
被final修饰的方法不能被重写
被static修饰的方法不能被重写
如果子父类中的同名方法,父类中是静态的,子类中的同名方法要求也要被static修饰
super
super和this的区别
this 指代当前new的对象
super 指代父类对象
super用在构造器的首行调用父类中的构造器
super(参数列表)
必须要使用再首行,没有没有显示调用父类中其他构造器,默认调用父类空构造
super区分子父类中同名的成员
如果不存在子父类中同名成员问题,可以省略,默认之类中的找子类,父类中的找父类
如果存在子父类中同名成员,并且想要调用父类中的成员,使用super表示父类对象,否则默认子类(就近原则)
创建对象是先父类后子类
先静态后成员
final最终的
final修饰变量为常量
final修饰的方法不能被重写
final修饰的类不能被继承(太监类)
final修饰的是引用数据类型,对象的地址不能变,但是可以改变对象的成员
equals
equals 和 ==的区别
== 比较对象的地址的是否相同
equals如果子类中没有重写,默认调用Object类中的equals方法,比较的是地址,但是可以重写,自定义比较规则,按照内容比较对象是否相同
Object类
是java中所有类的根据类
java中的所有类都会直接或者间接的继承自Object类
toString() 方法
当打印一个对象的引用时候,默认调用对象的toString()
当打印一个对象,其实是想要看对象的所有属性的值
重写toString()方法,自定义输出对象属性的内容,实现打印对象的属性值,不打印地址,默认打印的对象的地址,因为默认调用Object类型的toString()
多态
一种事物的多种形态,多种表示形式
多态的前提
类的继承
接口的实现
多态的最终体现
父类的引用指向子类的对象
多态的目的
父类的引用在如果调用子父类中都有的方法,调用的是子类中重写的方法
子类的新增方法对父类引用不可见
多态使用成员
成员变量: 编译运行看父类
成员方法: 编译看父类|类型|左边,运行看子类|找对象|右边
继承
继承链 、自己没有找父亲
A
B
C
编译看类型（确定方法表）、运行找对象
成员方法:编译看左边|类型 运行看右边|对象
就近最优原则：自己没有找父亲
基类对子类新增方法不可见
编译时确定方法表:多态能够调用的方法
转型(cast)
向上转型:(自动类型提升)
例: Fu zi=Zi();
向下转型:(强制类型转换)
例: Zi zi1=(zi)zi();
可以调用子类中新增的方法
A instanceof B
判断A引用是否是B类型的对象|是否是B类型子类的对象,如果是返回true,如果不是返回false
编译的时候只检查A和B是否在一条继承连上
abstract
使用abstract关键修饰的方法为抽想法方法
没有方法体
必须存在与抽象类中
抽象类
abstract修饰的类就是抽象类
注意事项
抽象类不能实例化
抽象方法一定要存在抽象类中
抽象方法一定要被重写才能使用
抽象类中可以存在抽象方法,可以存在实例方法
使用抽象类中的内容:
通过子类
具体子类:重写抽象父类中的所有抽想方法+按需新增方法
抽象子类:按需重写抽象方法+按需新增
一个抽象方法如果被重写过就不需要再次被重写了,但是也可以重写
abstract不能和private,final,static和native不能一起使用
接口
一种特殊的抽象类
是一个事物额外的功能
如果父类的功能是有功能体实现的,也有只定义功能子类可以具有的功能但是没有实现,可以抽象类
优点
提高代码的复用性
解耦
定义编程规范
接口多实现
使用interface定义接口
组成(1.7之前)
属性:public static final公共的静态的常量(可以省略,默认)
方法:public abstract 公共的抽象的方法(默认,可以不写)
1.8新增
静态方法
使用:只能通过接口名字调用
默认的方法
使用:只能通过实现类的对象使用
注意
接口不能实例化
具体的实现类:实现了接口,就要重写这个接口中的所有抽象方法+按需新增
抽象的实现类:重写部分抽象功能+按需新增
接口需要实现,实现接口使用关键字implements,实现了接口就拥有了接口中的功能(与继承很像)
具体的实现类:实现了接口,就要重写这个接口中的所有抽象方法+按需新增
抽象的实现类:重写部分抽象功能+按需新增
接口的使用:
具体的实现类:实现了接口,就要重写这个接口中的所有抽象方法+按需新增
抽象的实现类:重写部分抽象功能+按需新增
类只能实现接口,不能继承接口,但是类只能继承类,不能实现类 类单继承类,类多实现接口
接口不能继承和实现类,接口只能继承接口,不能实现接口,接口可以多继承接口
一个类要先继承后实现
单例模式
保证一个类只能构建一个实例
饿汉式
在类第一次加载的时候就创建实例
线程安全的
懒汉式
第一次调用功能的时候创建实例
线程不安全的,效率较高
步骤
构造器私有化
私有的静态的该类的引用
公共的静态的访问方式
静态代理模式
真是角色和代理角色实现相同的接口|父类
代理角色持有真实角色的引用
代理行为
优势
降低了与真实角色的交流,减少代码的耦合度,便于后去维护和扩展
简单工厂模式
抽象产品角色:具体产品角色实现的接口|继承的父类
内部类
成员内部类
内部类定义在外部类的成员位置
成员:可以使用成员修饰符,public static ...
类:可以继承类,可以实现接口
内部类中可以直接使用外部类中的所有的内容,包括私有的
内部类中不可以直接定义静态的内容,除了静态的常量,静态的内容要定义在静态内部类当中
其他类中测试使用内部类中的内容
Outer01.Inner in=out.new Inner();
Outer01.Inner in=new Outer01().new Inner();
局部内部类
局部内部类不可以使用成员修饰符修饰(比如:public,static...不包括final)
只能在当前定义局部内部类的方法中可以通过内部类的对象使用内部类中的成员,通过类可以使用静态
局部内部类所再的方法的参数,在jdk1.8之后默认,1.7之前需要显示定义
私有内部类
私有内部类中可以使用外部类中所有的内容,包括私有的
私有内部类只能在外部类中可以通过对象使用私有内部类中的私有内容,其他类中不能使用
静态内部类
静态内部类可以定义静态的内容可以定义成员的内容
在静态内部类中使用外部类中的非静态的内容,要通过外部类的对象去使用
在外部类中可以通过类名使用静态内部类中的静态内容,需要通过对象使用静态内部类中的成员内容
在其他类中可以通过外部类名.静态内部类名.静态内容使用静态内部类中的静态内容
new 外部类.静态内容类() 创建静态内部类的对象使用静态内部类中的成员
匿名内部类
没有名字的内部类
简化没有独自作用|功能的实现|子类
用完销毁,不能使用第二次
引用接收匿名内部类对象的地址---接口多态
Lambda表达式
目标:简化匿名内部类
语法: ()->{}
() :-->重写的抽象方法的参数列表
-> :箭头符号,箭头函数,Lambda符号
{} :重写的抽象方法的方法体
前提:函数式接口
函数式接口:只有一个抽象方法的接口就是函数式接口
@FunctionalInterface : 强制检查是否为函数式接口
数组
相同数据类型的有序集合
特点
数组是引用数据类型
数组是定长的,长度一旦确定不可改变
数组中所有数据的数据类型保持一致
数组中的数据存在顺序(索引:从0开始)
声明方式
数据类型[] 数组名;
数据类型:可以是基本数据类型|引用数据类型
数据类型的作用:规定数组中所有数据的数据类型
初始化
动态初始化:先创建后赋值
数据类型[] 数组名 = new 数据类型[长度];
数组中的数据如果不赋值有默认值
静态初始化:创建的同时赋值
数据类型[] 数组名 =new 数据类型[]{值1,值2,值3...};
数据类型[] 数组名 ={值1,值2,值3...}; --推荐
操作(获取|修改)数组中的数据
通过索引操作 数组名[索引|下标]
长度
数组名.length
数组中最后一个数据的下标
数组名.length-1
遍历
普通for循环,可以获取可以修改,因为是操作索引(位置)
增强for循环|for..each ,只能获取每一个数据,不能修改
for(数据类型 变量名: 数组名|容器名){
变量-->指代数组中的每一个数据
}
数组索引越界异常
ArrayIndexOutOfBoundsException
索引为负数
索引超出最大范围
可变参数
数据类型相同的0~多个参数
使用...表示可变参数
编译器会自动为可变参数隐式创建一个数组,通过操作数组的方式使用可变参数
可变参数必须放在参数列表的最后位置
二维数组
数组中嵌套数组就是二维数组
声明
数据类型[][] 数组名; --推荐
数据类型 数组名[][];
初始化
动态
数据类型[][] 数组名 = new 数据类型[一维的长度][二维的长度];--每一个第二位的小数组长度相同
数据类型[][] 数组名 = new 数据类型[一维的长度][];--第二位的每一个小数组的长度可以不同,第二位的小数组还没有创建
每个数组 arr[外层数组索引]=new 数据类型[长度] |...一维数组创建方式
静态
数据类型[][] 数组名 = new 数据类型[][]{{1,2},{1},{1,2,3}...};
数据类型[][] 数组名 = {{1,2},{1},{1,2,3}...};
遍历
双重for循环嵌套
异常
Throwable
Error
这类错误一般是虚拟机生产或脱出的,程序员无法控制,不需要管
Exception
CheckedException
检查时异常|编译时异常 CheckedException:如果遇到,必须进行处理,否则程序无法运行,发生在编译期
RuntimeException
运行时异常 RuntimeException:程序运行才知道是否有异常 增强程序的健壮性处理 if..
常见的一些运行时异常
空指针异常NullPointerException
数组下标越界 ArrayIndexOutOfBoundsException
负数异常 NegativeArraySizeException
数学异常 ArithmeticException
字符串索引越界异常 StringIndexOutOfBoundsException
throw(制造异常)
异常处理方式
抛出异常: throws 把异常抛到上一层
捕获异常:
try{
可能会出现异常的代码
}catch(ClassNotFoundException e){ //= new ClassNotFoundException();
如果出现ClassNotFoundException类型的异常,执行这里的代码....
}catch(NullPointerException e){
如果出现NullPointerException异常,执行这里的代码
}...
catch(Exception e){
接收除了以上的其他的异常,执行这里的代码
}finally{
无论try中的代码是否出现异常,finally中这里的内容一定会执行
}
注意
try后面可以接一个到多个catch,捕获不同类型的异常
把大范围的catch写在最后,小范围写在前面,否则永远执行不到
如果try中一旦出现异常,try中的后面的代码都不会执行,执行对应catch中的代码
自定义异常
异常处理
编译时异常:1)throws 2)try..catch
运行时异常:1)增强程序健壮性 2)throws 3)try..catch
java基础,还有你不会的,那就进来看看吧
猜你喜欢
转载自blog.csdn.net/weixin_45116982/article/details/91357552
今日推荐
周排行