目录
1、JAVA概述
1.1程序设计语言
- 机器语言
- 汇编语言
- 高级语言
1.2Java的特点
- 简单性
- 面向对象
- 安全性
- 平台独立
- 多线程
- 网络功能
- 执行效率
1.3JDK的设置
Path:--------à是bin目录
ClassPath----à是lib目录
1.4编译和运行java程序
编译:javac 文件名.java
运行:java 文件名
2、Java基础
2.1标识符和关键字
2.1.1标识符
由字母、数字、下划线、和美元符组成,且第一个字符不能是数字!
不成文的约定:
- 类名首字母大写;
- 常量名全部字母大写;
- 其余的全小写,但第二个单词的第一个字母大写
2.1.2关键字:
int 整型 | long 长整型 | float 浮点型 | double 双精度 | char 字符 |
byte 字节 | boolean 布尔型 | final 常量 | if 如果 | else 其它 |
switch 开关 | case 事例 | break 跳出循环 | default 违约 | for 循环 |
continue 跳出当前循环 | do | while 在..之间 | null 空 | this 当前对象 |
implements 实现接口 | package 包 | extends 继承 | class 类 | void 空的 |
static 静态的 | return 返回 | import 导包 | true 真 | false 假 |
private 私有的 | protected 保护的 | public 公共的 | abstract 抽象的 | new 新的 |
super 父类 | throws 抛出异常 | throw 抛出异常 | Instanceof 类型检查 | transient |
catch | finally | native | synchronized | volatile |
Instanceof //对于父对象的类型检查,父类是否是子类的类型
//用于检查当前Object对象的类型 是不是为Integer
If(obj Instanceof Integer){}
2.2数据类型与常量、变量
Long 长整型 8字节
Int 整型 4字节
Short 短整型 2字节
Byte 字节 1字节
Float 单精度浮点型 4字节
Double 双精度浮点型 8字节
2.2.1字符类型(char)
Char ch=’a’;
转义字符 功能
\b 退格
\t 小平制表
\n 换行
\r 回车
2.2.2布尔型(Boolean)
True(真) false(假)
2.2.3常量(final)
[修饰符] 类型标识符 常量名 =(直接)常量;
Final float PI = 3.14;
2.2.4变量
[修饰符] 类型标识符 变量名 [=常量];
float a =2.5;
2.3运算符和表达式
2.3.1运算符
- 单目运算符:自增(++)、自减(--)、绝对值(-)
- 双目运算符:加(+)、减(-)、乘(*)、除(/)、取余(%)
- 三目运算符:表达式1 ?表达式2 :表达式3
- 关系运算符:大于( >)、小于(<)、等于(==)、
大于等于(>=)、小于等于(<=)、不等于(!=)
- 逻辑运算符:与(&)、或(|)、非(!)、异或(^)、条件与(&&)、条件或(||)
- 位运算:
运算符 用例 功能
~ ~a 将a逐位取反
& a&b a、b逐位进行与操作
| a|b a、b逐位进行或操作
^ a^b a、b逐位进行异或操作
<< a<<b a向左移动b位
>> a>>b a向右移动b位
>>> a>>>b a向右称动b位移动后的空位用0填充
2.3.2数据类型转换
由高到低:
Double
Float
Long
Int
Short
Byte
3、基本控制结构
3.1顺序结构
3.2选择结构
3.2.1 If 语句
if(布尔表达式){//为真就执行语句1
语句1
}else if(布尔表达式){//为真就执行语句2
语句2
}else{//为假就执行语句3
语句3
}
3.2.2 switch语句
switch(变量){
case 常量 1:语句1;break;
case 常量 2:语句2;break;
………
default:语句n
}
3.3循环结构
3.3.1While语句
While(布尔表达式){
循环体
}
3.3.2Do…while
Do{
循环体
}while(布尔表达式);
3.3.3for语句
For(int i=1;i<=100;i++){
循环体
}
3.3.4多重循环
For(){
外循环体
For(){
内循环体
}
}
3.4跳转语句
Break语句--------->退出循环
Continue语句------->退出当次循环
4、方法
4.1书写方法的格式:
修饰符 返回值 方法名 调用过程中 方法体
可能出现的例外
public int/void addNumber(参数) throw Excepion {}
例:
public int addNumber(int a,int b){
}
注:方法名中的参数int a,int b为局部变量
4.2方法声明
[修饰符] 类型标识符 方法名 ([形参列表]){
声明部分
语句部分
}
注:方法分为:有返回值、无返回值;或都可以分为有参或无参!
有返回值的方法必须在最后一句中有:return(表达式)
4.3方法调用
方法名(【实际参数】)
注:参数传递时 形参 是不能改变实际的,只有参数传递时,所传的是数据地址时,实参才会改变!
4.4递归
n!=n*(n-1)!
(n-1)!=(n-1)*(n-2)!
import java.util.Scanner;//导包
publicclass 递归算法 {
/**
* 采用递归算法求n!
* fac()=1 n=1
* n*fac(n-1) n>1
*/
publicstaticvoid main(String[] args) {
递归算法 cjc = new 递归算法();//实例化类对像
Scanner sc = new Scanner(System.in);
int k = sc.nextInt();//输入
long f = cjc.fac(k);//调用方法
System.out.println(f);
}
publiclong fac(int n) {//定义一个方法
if (n == 1) {
return 1;
} else {
return n * fac(n - 1);// 递归调用
}
}
}
5、数组
5.1一维数组
注:
传引用(地址传递):数组在进行方法的参数传递的时候,传的是数组的首地址,那就意味着在调用的时候,方法里面处理的那个数组就是调用时传入的数组;
所以能够对传入的数组产生影响(比如:数组,或者类的对象,string)
传值(值传递):传入的值的拷贝,那么传入的变量,和方法体的变量不是一回事;
所以方法体不能对传入的变量产生作用(比如:值类型int double char float)该类型的变量,
如果能(.)出东西来,那么就是引用类型,反之则不是
5.1.1声明
类型标识符 数组名[]
或
类型标识符[] 数组名
5.1.2初始化数组
类型标识符[] 数组名=new 类型标识符[元素个数]
或
类型标识符 数组名[]={初值表}
5.1.3数组长度
数组名.length
5.2多维数组
和一维数组一样
5.3数组长度
行数: 列数:
数组名.length 数组名[行标].length
数组排序:Arrays.sort(a);//对数组a进行排序
6、字符串
6.1字符串变量的声明和初始化
String 字符串变量=new String( );
6.2字符串操作
6.2.1访问字符串
- length( ) // 提取字符串长度
int n=str.length();
- char charAt(int index) //提取字符串中的第index个字符
char ch=str.charAt(int 3); //提取第三个字符
- int indexOf(int ch) //返回”个“在字符串中的下标
- int indexOf(String str,int index) //返回”字符串“在字符串中从7开始出现的位置
- substring(int index1,int index2) //提取出从3到8之间这一个子字符串
publicstaticvoid main(String[] args) {
String str = new String("这是一个字符串操作的测试程序");
int n = str.length();//提取字符串长度
char ch = str.charAt(5);//提取字符串中下标为5的字符
int n2 = str.indexOf('个');//返回”个“在字符串中的下标
int n3 = str.indexOf("字符串",7);//返回”字符串“在字符串中从7开始出现的位置
String str2 = str.substring(3, 8);//提取出从3到8之间这一个子字符串
System.out.println(n);//14
System.out.println(ch);// 符
System.out.println(n2);// 3
System.out.println(n3);// -1
System.out.println(str2);// 个字符串操作
}
6.2.2字符串比较
equals(object obj) //区分大小写字符串比较
equalsIgnoreCase(String str) //不区分大小写的字符串比较
compareTo(String str) //比较二个字符串的大小
6.2.3数据类型转换
String.valueof(基本类型数据)
7、类和对象
什么是对象:EVERYTHING IS OBJECT(万物皆对象)
7.1架构师的思维方式:
当你设计类的时候:
- 你设计类是由你模拟的事务决定;
- 类的属性,仅限于你需要用到的;
- 设计类的行为的时候,用第一人称的视角来思考,假如你就是那个类,那么你的行为是什么;
- 对于行为方法中不能写死的东西,可以考虑用方法的参数来传入;
- 对于方法参数和方法的返回值,不在局限于 int double 之类的基本类数据类型,而是扩展到所有你自己定义的复杂的数据类型;
- 在进行方法的设计的时候,先考虑参数,后考虑反回值;
- 在实现方法的时候,想清楚你和被你施加动作的东西,想清楚动作施加了之后你发生了什么变化,被你施加动作的东西发生了什么变化。
注意:在对象变量中存放的是引用(地址);在简单变量中存放的是数值。
面向对象思想来源:我们因需要描述更加复杂的现实世界,比如星际争霸的场面,需要有更多的数据类型,但是正常情况下,我们没有,我们只有int、double等等,一些简单的数据类型,所以,我们需要创建更多更复杂的数据类型。
面向对象技术,让我们能够追寻更加复杂的数据类型,来模拟我们的现实世界
面向对象和面向过程的区别:面向对象的思维方式,不再是一开始就去想一步步的步骤,而是先创建模拟世界中间需要的复杂的数据类型
星际争霸:
先创建复杂数据类型,比如机枪兵类型,飞龙类型
创建了之后才去实现具体的过程
面向对象的好处:1、能够帮助我们更加形象的写出人性化的程序
2、能够实现内容的封装,比如:兵1.攻击(飞龙1)
3、能够让代码变得更加简洁,继承等面向对象的技术
4、能够让你站在巨人的肩膀上
7.2注意区分:对象(本身)、对象的实现者、对象的调用者。
分析对象主要从方法开始。
我们通过类来看待对象,类是对象的抽象。其次,采用面向对象方法可以使系统各部分各司其职、各尽所能。
7.3面向对象内存结构
//所有变量都是存在栈中的,只是值类型存值,而引用类型存地址
创建对象时,分两步:
第一步是在堆中开辟空间,存放该新创建的对象
第二步是在栈中开辟空间,存放是该对象在堆中的首地址
堆和栈本质上都是内存中的一段区域,他们是不同的区域,分别取名为堆和栈,
功能使用上有不同,在创建对象时,堆存储的是对象,栈存储的是对象的首地址
java中,数据类型
值类型(基本数据类型)数值类型:int double long float
非数值类型:char
值类存储在栈里
引用类型:数组,字符串,对象
引用类型存储在堆里,但是栈里有一个空间存储该引用类型的首地址
值类型和引用类型的访问效率问题:
1、值类型直接在栈中进行访问,效率最高
2、引用类型是通过访问栈中存储的对象的首地址,然后找到对应堆中地址的对象,所以引用类型的访问效率低
变量都是存在栈里的,只不是值类型的变量直存储的是值,而引用类型的变量存储的是堆中对象的首地址
定义引用类型的变量时,如果不让它引用对象,而又要初始化,那么我们一般设定为null
null 表示空的意思。null本质上就是0,低表的就是0地址,对于0地址的空间,系统是不允许占用,所以,可以统一用于表示空对旬或者说没有引用任何对象。
7.4类的声明
【修饰符】class 类名【extends 父类名】【implements 接口名列表】{
成员变量声明部分
成员方法声明部分
}
7.5实例化对象
实例化对象:
类名 对象名=new 类名(形参列表);
对象使用:
对象名.成员变量名;
或
对象名.方法名(实参列表);
7.6构造方法:
- 方法名与类名相同的方法称为构造方法;
- 构造方法没有返回值,前面不能有返回值类型,也不能有void;
- 程序中不能直接调用构造方法;
- 构造方法没有返回值。格式为:public 方法名。
- 构造方法是在对象生成的过程中自动调用,不可能利用指令去调用。
- 如果我们未给系统提供一个构造方法,那么系统会自动提供一个为空的构造方法。
一个类可以构造多个构造方法,但多个构造方法的参数表一定不同,参数顺序不同即属于不同的构造方法:
public student(string name,int a){
}
public student(int a,string name){
}
8、类的封装
8.1访问权限
Java中共有四种访问权限:public(公有的)、protected(受保护的)、缺省的和private(私有的)
访问权限
权限修饰符 | 本类 | 本类所在的包 | 其他包中的子类 | 其他包中的非子类 |
Public | √ | √ | √ | √ |
Protected | √ | √ | √ | — |
缺省 | √ | √ | — | — |
Private | √ | — | — | — |
8.2类成员
类名. 类成员变量名
或
对象名. 类成员变量名
或
类名.类成员方法名()
或
对象名.类成员方法名()
类成员是属于类的,类成员需要使用static(静态的) 修饰,类成员也称为静态成员。类成员包括类成员变量和方法。通过类名可以直接访问类成员变量、调用类成员方法即使没有创建对象,也可以引用类成员。类成员也可以通过对象名引用。
publicclass 类成员变量 {
String name; //实例成员变量
String sex; //实例成员变量
staticintcount=0;//类成员变量
publicstaticvoid main(String []args){
System.out.println(类成员变量.count);//直接调用类成员变量
}
}
8.3实例成员变量的使用:
必须先要定义类对象:
对象名.实例成员变量名
或
对象名.实例成员方法
静态(Static) //静态的--->也就是类的专属
1、我们一般情况下,定义的属性,通常都属于该类型的个体,是具体对象所拥有的属性,比如名字,年龄,这些都是具体对象的属性。具体对象的属性可以通过(通过对象,属性实现调用)
2、但是还存在另外一钏属性,它不再单单隶属于某些个体,而属于类的。比如:人类的数量这种属性。(通过类,属性调用)
3、当你new对象的时候,第一次new的时候,系统首先会加载类,把它作为产生对象的模板,在这个模板中,包含类的(静态的),也包含对象的,类一经加载过后,无需再次加载。
4、new对象的时候,对象通过类的模板,实施对应拷贝,但是只会包含对象的成类,而不会包含类的成员。
5、属于类的成员,只会有一个。比如人类的数量这样一个成员,就只有一个,但是属于人对象的年龄,则是每个具体的对象一个。
6、对象(非静态)的方法中,可以访问类(静态)的属性和方法。
7、静态的方法中,可以访问该类的静态属性。
8、静态的方法中, 不可以直接访问该类的非静态属性,除非new对象,用对象来调用
9、静态块
static{
//这里面写静态属性,给他们赋值
}
静态块是在类被加载的时候自动调用的,但它只被调用一次;
静态块的作用:静态块一般用于实现静态属性的初始化;可以放置更多,更复杂的初始化代码,而不是仅仅只是个初值。
10、非静态块
{//这是一个非静态块
//代码区
}
非静态块是在new 对象时候自动调用 的,只是先于构造方法执行(在构造方法之前执行)
非静态块的作用类似于构造方法,都用于非静态属性的初始化。
11、单例模式
什么时单例模式:限制只能创建一个对象的设计模式(面向对象的应用)
8.4什么情况下直接调用属性,什么情况下调用封装属性的get 和set 方法
- 类中:(调用自己的)
在本类中,如果需要访问自己的属性,一般情况下直接调用属性来访问; 但在写构造方法的时候,最好要用自己封装的set属性方法来完成参数的初始化。
- 类外:(调用别人的)
类中间调用其他的类的属性的时候,那么如果对方的属性是非公共的,那么只能通过对方提供的公共的get或set方法来实现访问。
8.5数学函数类方法
Math.方法名( )
Sin(double x)
Cos(double x)
Log(double x) //返回X的自然对数
exp(double x) //返回E的X次方
abs(double x) //返回X的绝对值
max(double x,double y) //返回X和Y中的较大值
sqrt(double x) //返回X的平方根
random(double x) //返回[0,1]区间内的随机数
pow(double x,double y) //返回y的x次方法
9、类的继承
9.1继承的实现
9.1.1定义子类
【修饰符】 class 类名 extends 父类名{
成员变量声名部分
成员方法声明部分
}
9.1.2继承原则
除父类构造方法和私有属性外全部继承
9.1.3Super引用
引用父类成员变量:
Super.成员变量名
调用父类成员方法:
Super.成员方法名( )
调用父构造方法:
Super( 参数表 )
9.1.4This引用
访问成员变量:
This.成员变量
调用成员方法:
This.成员方法( 参数表 )
调用构造方法:
This( 参数表 )
9.2类的多态性
9.2.1方法重载
方法名相同,但方法类型或参数列表不一样,就称之为重载
9.2.2方法覆盖
子类与父类方法头完全一样,但方法体不一样,称之为覆盖
10、Final类和final成员
不能改变,不能继承
11、抽象类和方法
声明抽象类:
【权限修饰符】 abstract 类名{
类体;
}
声明抽象方法:
【权限修饰符】 abstract 返回值类型 方法名(参数表);
- 抽象方法只有方法头没有方法体;
- 有抽象方法的类必须是抽象类;
- 抽象类不能被实例化;
- 继承抽象类必须实现类中所有抽象方法。
12、接口
12.1声明接口
【public】 interface 接口名 【extends 父接口名】{
(常量)成员变量表
(抽象)成员方法表
}
成员变量声明形式:
【public】【static】【final】成员变量名=常量;
成员方法声明形式:
【public】【abstract】返回值类型 成员方法名(参数表)
12.2实现接口
【修饰符】 class 类名【extends】 implements 接口名1,接口名{
类体
}
注:接口可以定义多重继承;接口中的方法全为抽象方法
13、包
13.1声名包
Package 包名;
13.2使用包中的类
包名.类名
或
包名.接口名
或
Mypackage.cpoint point=new mypackage.cpoint(参数表);
13.3导入包中的类
Import 包名.类名
Import 包名.接口名
Import 包名.*
14、输入输出
15、设计模式
设计模式:需要区分设计者和调用者,要站在设计者的角度和调用者的角度去思考设计模式。
典型的代表是:工厂模式 和 单例模式
15.1单例模式
15.1.1什么时单例模式:限制只能创建一个对象的设计模式(面向对象的应用)
15.1.2单例模式实例
publicclass Dog {
static Dog i = null;//
String name;
private Dog(String name) {//私有构造方法
this.name = name;
}
publicstatic Dog setDog(String name) {
if (i == null) {//限制只能创建一个对象的设计模式
Dog go = new Dog(name);
i = go;
return go;
} else {
returnnull;
}
}
}
15.2工厂模式
15.2.1工厂模式:
创建一个工厂类(Factory),在工厂类中实现一个创建对象的方法(createInstance)
通过传入的类型,返回对应的对象,通过这种方式,类的开发者实现了对象创建的封装,这个方法的返回值一般是所创建对象类型的父类类型,
类的调用者:类的调用者通过这个工厂对象来得到他所需要的对象,而不需要关心中间的细节。
15.2.2工厂模式实例:
publicclass Factory {
// 创建对象的方法:传入要创建对象的类型
// 返回创建的对象
// 如 JiQiangBin jqb= createInstance(“机枪兵”);
// KuangGong kg=createInstance("矿工");
publicstatic Bin createInstance(String type) {
// 判断传入的类型,创建并返回对应的对象
if (type.equals("机枪兵")) {
Bin bin = new JiQiangBin();
return bin;
} elseif (type.equals("矿工")) {
Bin kg = new KuangGong();
return kg;
} else {
returnnull;
}
}
}
16 java集合框架
集合类存放于java.util包中
集合:提供对数据可扩展(变长的)存储(存放元素的个数不确定)
分为两大类:Collection接口与Map接口
16.1、Collection接口:线性结构的存储(类似数组的存储)
a、集Set接口:
作用:不可以存储重复元素,存储元素的先后顺序是无序的
- HashSet 无序时使用
- TreeSet 排序时使用
b、列表List接口:
作用:可以存储重复元素,存储元素的先后顺序是有序的
- Arraylist 利于查找
- LinkedList 利于添加删除数据
- Vector 线程安全(同步)
16.2、Map接口:存储数据是基于Key / value对
- HashMap
- TreeMap 用于排序
16.3、中文排序问题
17 Java 泛型
泛型(jdk1.5):限制集合元素中存储的元素必须相同; 还可以将类作为一个
* 模版类; 泛型的应用是由对象来决定,而不是类。