Java基础(二)
Java基础(二)
1. while循环
while循环---线判断在执行
循环—就是重复发生的过程(循环一般有充分的前提条件)
语法:while(表达式){循环体}循环体如果是true就执行循环,如果是flase就结束循环
do while循环---先执行在判断
语法:do{循环体}while(循环条件)
2. for循环
语法:for(表达式1,表达式2,表达式3){
循环体
}
表达式1:计数器的初始化,他只执行一次
表达式2:循环条件的判断,他多次执行
表达式3:计数器的累加,多次执行
3. break和continue
break:跳出当前上层循环
continue:终止当前的本次循环,但是不会终止后续的循环
4.函数和数组
1. 函数(也叫方法)
是一段能完成独立功能的代码块,我们可以写一次方法,多次调用,提高了的代码的复用性
语法:
<public> <static> 返回值类型【void】方法名(【数据类型 变量名,数据类型1 变量名1,………】){
//方法体
【return 结果值】;------返回值
}
返回值类型[void]:返回值类型就是函数执行后要给调用者的数据类型
就必须有return,如果是void就不用return
2. 方法调用的内存分析
3. 图解方法调用的内存分析
我们管主函数调用时所传递的变量a,b叫做实参,方法中的参数叫做形参,我们调用方法时是通过值传递的方式吧实参的值传给方法的形参
Java语言中只有值传递
传递参数时数据类型必须一致,在retuen后面的代码是无法访问的
2.数组的定义
引用数据类型都必须用new
定义数组的语法
语法:数据类型[ ] 数据名=new 数据类型[整数]
语法 数据定义[ ] 数组变量名=new数据类型[ ]{ 数组的值}
整数:指的是数组的长度
栈:空间小,主要存储地址和基本类型的变量,存取速度快
堆:空间大,主要存储引用类型的变量,存取速度慢
我们操作数组是通过数组的下标老操作数组的
数组分配空间的图
Int[] arr=new int[5];
数组的内存结构
1. 注意数组月结的问题
2. 数组在内存中的结构,在java中,内存被分为两种,一种是栈,一种是堆,
栈----容量小,存取速度快,适合存储生命周期短的数据,栈中存储变量,数据变量,
特点---先进后出
堆----容量大,存取速度慢,适合存储生命周期长的数据,适合存储对象
特点-----随便拿数据
3. 遍历数组
数组的遍历
求及值-----最大值
求及值-----最小值
4,冒泡排序
冒泡排序的定义---相邻的两个数逐个的做比较,如果前一个数比较后一个数小那么就交换过来,当第一轮比较完毕后最小的值一定产生在末尾
23,1,32,7,13进行冒泡排序
冒泡排序的方法
5.二分法查找
前提条件----是对有序的数组进行查找,效率高
return midindex;
数组的倒置
5. 二维数组
数组中还有数组就是,数组可以有n维
语法----数据类型 [ ] [ ] 数组名=new 数据类型[整数 ] [ ];
二维数组的长度第一维是必须指定长度的
5.方法的重载
重载(overload)的概念:在一个类中有两个或者两个以上同名的方法,但是方法的参数不同(指的是两个方法的参数的个数不同,还有就是方法的参数类型不同),与返回值无关
方法的重载目的在于提高代码的可读性与节省命名的词
示例方法的重载,(里面有多层调用)----第二张图是简易写法
6. 面向对象-------真正的java语言
1.面向过程 c语言
分析解决问题的所需要的步骤,然后我们用函数一步一步的调用实现
2.面向对象(oop)-----面向对象编程
面向对象的思想就是抽取一类基友相同属性和行为的事务,在java中,万物皆对象,对象是一个具体的实物
3.类
我们把某些具有相同的属性和行为的四五抽象成一类
类 类似一个模版的东西,对象是根据这个模版产生的样本
类是一个概念,是抽象的
对象,是一个实物
类的语法
Class 类名{
属性-----成员变量
行为-----方法
}
属性(成员变量)的定义
数据类型 变量名=初始值(也可以不给初始值)
类是一个概念,不能直接使用,需要实例化这个类才可以用
根据类来实例化对象
语法 类名 (数据类型) 变量名=new类名();
如何给一个具体你的对象来赋值---对象的变量.属性名=具体值
4. 匿名对象
匿名对象是没有意义的,实际开发中最好不要用匿名对象,
7. 封装
Private只能在本类中访问
封装的目的-------------提高数据的安全性,通过封装,可以实现对属性的访问权限控制,同时增加了程序的可维护性
将属性私有化,提供外部访问的公有化方法-----set赋值的方法和get外部访问的方法
This关键字------代表的是当前的
8. 构造器
构造器的方法作用就是给类的属性赋初始值,构造器的方法必须和类名一直,有无参数构造和有参数构造
9. static关键字修饰属性
语法:sttic 数据类型变量名;
使用tatic修饰符的修饰的属性我们认为是类的属性,不带static修饰的属性我们认为是对象的属性
类属性访问
第一种方式:类名.属性名(推荐使用)
第二种方式:对象实例.类属性
10. static关键值修饰方法
语法:public static 返回值(void)方法名(数据类型1 变量1,数据类型2 变量2){
方法体
[return结果]
}
Static修饰在方法上就是类方法
11.单例模式(singleton)--------设计模式
1.懒汉---在类加载的时间就创建了对象
构造器私有化
在类内部new自己本身(是私有的)
package webjavascript;
publicclass Singleton { //在单例类内部创建自己本身的对象 privatestatic Singleton s=new Singleton(); //构造器的私有化 private Singleton(){
} //获得单例的对象 publicstatic Singleton getSingleton(){ returns; } publicstaticvoid main(String[] args) { //内存空间永远只有这一个对象 System.out.println(Singleton.getSingleton()); } }
|
2.饿汉模式-----在调用的时间在创建对象
package webjavascript; /** * 单例模式饿汉 * @author Administrator * */ publicclass Singleton1 { privatestatic Singleton1 s1; private Singleton1(){
} publicstatic Singleton1 getSingleton1(){ if(s1==null){ s1=new Singleton1(); } returns1; } publicstaticvoid main(String[] args) { System.out.println(Singleton1.getSingleton1()); } }
|
11. 类的继承
定义一个公共的类,这个类有其他类共有的属性行为和方法----我们就采用继承来减少代码的冗余
继承的语法----使用extendes关键字
class 子类 extendes 父类{
子类的属性
子类的方法
}
继承的特点:子类会把父类所有的属性和方法继承下来
Note-----final修饰的类是不能被继承的
12. supper
1. 子类实例化的过程中父类的构造器先被调用,然后字调用子类的构造器
2. 子类通过构造器实例化时要调用父类的默认构造器,是隐含了supper()这个方法,但是如果子类的构造器中调用了父类的有参数的构造器,那么无惨的构造器就不会被调用了
3. Supper的调用必须要放在方法的第一行
4. Supper可以表示父类的引用,我们可以使用supper和this关键字来区分父类和子类中同名的属性,在子类中访问属性的查找顺序首先在子类中查找指定的属性的名字,如果在类中没有该属性,就会去父类中去找,
This关键字
代表当前类的指定示例的引用
可以区分同名的的属性和去不变量
通过this关键字可以调用同类中的构造器(this(),this(参数列表))
调用本类里面的属性,this.属性名,this.方法()
super关键字用法
supper.xxxx-----代表的是调用父类的属性或者行为
方法重写(override)
在类中如果有一个方法和父类的方法名一样,就代表着重写了父类的方法,这样的话在使用这个类的时间就不会使用父类中的方法了
final的使用方法
final可以作用在属性,类,方法
如果final修饰类---代表类不能被继承
如果final修饰属性------属性的值不能被改变
如果final修饰方法------代表方法不能被重写
常量的定义
13. 抽象类----absract
抽象方法概念
当多个具体的实体类存在着共同的行为,但是有不同的表现,我们在父类继承过程找那个父类的犯法具体实现不同确定,但是能确定
抽象类语法
abstract class------抽象类
public abstract 方法名-----抽象方法
抽象类不能被实例化
在类继承了抽象类,必须实现父类的所有的抽象方法
抽象类可以继承抽象类,这样的话就可以不用实现父类的抽象方法
抽象类不能和其他关键字共存---static,final,private
14. 接口
当一个抽象类,如果抽象类中的所有方法都是抽象的,那么我们就可以把它定义为一个接口,接口是对行为的抽象,类是对属性和行为的抽象
语法
Interface 借口名{
方法的定义
}
在接口中定义的所有的变量都是常量,默认就是被final,static修饰的,值是不能被改变的(常量字母都要大写)
接口的继承和实现
接口也可以继承接口,接口1.7之后可以多继承,接口也可以多实现,如果实现了某一接口,就必须实现接口里面的方法
使用接口的好处
1. 接口的定义是一种标准,可以是我们的代码分层开发,分模块开发
2. 降低代码的耦合度,提高代码的可扩展性和可维护性
3. 接口改进了单继承的局限
接口和抽象类的区别
1. 接口的所有方法都是抽象的,抽象类里面的方法可以是抽象的,也可以不是抽象的
2. 接口和抽象类都不能被实例化,接口需要类来实现后实例化实现类,抽象类需要类来继承后实例化子类
3. 抽象类智能单继承,接口可以多继承和多实现
4. 接口中的属性是static,finall类型的,抽象类中的属性和普通的类没有什么区别
5. 接口中的方法默认就是抽象的,不需要加absract,抽象类中的方法需要加adsract关键字
类的单继承原理
类是不可以多继承的-------例如两个类中有两个完全相同的方法,子类会不知道用哪个方法,
如果是接口的话会把两个完全相同的方法合成一个方法-----这就是接口的多继承
15.多态
多态就是行为具有表现多种功能的能力
接口的多态—接口的多态基本上类的继承多态是一样的,不同的是类的继承使用的是继承关系实现多态,接口采用实现的方式实现多态
16.Math类
自然对数---Math.E
圆周率----Math.pi
绝对值-----Math.abs(-1.5)
把小数去掉整数加一----Math.ceil
……………………………………查看帮助文档
包的定义
包---就是文件夹
作用---对类做分类管理,可以区分同名不同类的包
语法----package 包名;(不同级别用.来风格)
Scanner扫描器
第一步—导入Scanner---import java.util.Scanner
第二步-----创建对象-----Scanner s=new Scanner(System.in);
第三步-----使用功能---调用Scanner类的方法,例如int next…….等待我们从键盘输入一个数值
17.内部类,权限修饰符
类内部的类就是内部类
把一个类定义到另一个类中,那么内部的类就是内部类
注意—内部类不能直接创建
创建内部类的语法----外部类.内部类 变量名=new 外部类对象.new内部类对象
例如----- Outi.iner neibu = new Outi().new iner();
内部类的外部类的方法如果想要访问内部类的方法,必须创建内部类的对象,根据内部类的对象来访问
私有内部类
静态内部类的创建语法----外部类.内部类 变量名=new 外部类名.内部类对象
匿名类----就是这个类没有名字
接口不能实例化,但是我们在创建匿名类的时间可以借助接口----例如 new 接口名(){ 实现接口的方法};大括号后面一定要加分号;
访问权限修饰符
| Private | 默认 | Protected | Public |
类 | N | Y | N | Y |
方法 | Y | Y | Y | Y |
属性 | Y | Y | Y | Y |
四种访问权限修饰符的作用范围
在类上的权限修饰符都是public的,方法大多还public的(使用一些设计迷失可能会使用protected获得private),属性绝大多数都是private
访问权限修饰符对方法和属性的访问限制
| 同类中 | 同一个包,没父子类关系 | 不同的包有父子类关系 | 不同包也没有父子关系 |
Private |
|
|
|
|
默认 |
|
|
|
|
Protected |
|
|
|
|
Public |
|
|
|
|
18.object类
Object类是所有类的根类,所有的类都是直接或者间接的去继承object类
类object是类层次结构的根类,每个类都使用object作为超类,所有的对象,包括数组都实现这个类的方法
19.eclipse源码查看和outline视窗
查看源码
关联源代码
当看不到源代码的时间-----点击Attach Source---选择压缩包形式的----选择jdk源码路径src.zip----点击ok
20.异常的分类和处理
编译时异常和运行时异常
在我们写程序的的时间难免会出现错误,java中的异常机制为了提高我们程序的健壮性和容村性二存在
Throwable类是java语言中所有错误或异常的超类
throwable类是所有异常的超类
Exception类是编译时异常
runtimeException类是运行时异常
运行期异常的处理--------自行解决和抛出去
类型转换异常
数学异常
数组越界异常
类型转换异常
空指针异常
传递非法参数异常
异常中的finally-----
try{}finally{这里面的代码无论如何都会被执行}finally主要用于异常发生时释放资源
final,finally,finalize的区别
1.final可以修饰类,方法,如果在类上,类不能被继承,如果在方法上,方法不能被重写,如果修饰属性,值不能被改变
2.finally是和try,catch异常处理模块一起用的语句块,他在最后一定会被执行
3.finalize当堆中的对象没有任何引用是这个方法会被调用来做垃圾回收
编译期异常处理
自己处理和向上抛出
运行时异常要向上抛出
自定义异常
我们自己定义的异常都是运行时异常------继承runtimeException类,继承runtimeException构造器
自定义异常语法----------throw new 继承了runtimeException的类(“写上异常”)
21.字符串
数据类型----基本数据类型和引用数据类型(引用数据类型有类,接口,数组)
字符串是引用数据类型(存储在推中)
String类代表字符串----String类不能被继承
String str="abc";----------定义一个字符串变量
str存储在栈中
abc存储在数据共享区
字符串的值是不能改变的
String str="helloword";和String str1 = new String("helloword");的区别
Stringstr="helloword"---------- str存储在栈中,helloword存储在数据共享区(静态区)
Stringstr1 = new String("helloword")---------new String在堆中,str1在栈中,helloword在数据共享区(静态区)