>>a>>ba向右移动b位
>>>a>>>ba向右称动b位移动后的空位用0填充
2.3.2数据类型转换
由高到低:
Double
Float
Long
Int
Short
Byte
3、基本控制结构
3.1顺序结构
3.2选择结构
3.2.1If语句
if(布尔表达式){//为真就执行语句1
语句1
}elseif(布尔表达式){//为真就执行语句2
语句2
}else{//为假就执行语句3
语句3
}
3.2.2switch语句
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(inti=1;i<=100;i++){
循环体
}
3.3.4多重循环
For(){
外循环体
For(){
内循环体
}
}
3.4跳转语句
Break语句--------->退出循环
Continue语句------->退出当次循环
4、方法
4.1书写方法的格式:
修饰符返回值方法名调用过程中方法体
可能出现的例外
publicint/voidaddNumber(参数)throwExcepion{}
例:
publicintaddNumber(inta,intb){
}
注:
方法名中的参数inta,intb为局部变量
4.2方法声明
[修饰符]类型标识符方法名([形参列表]){
声明部分
语句部分
}
注:
方法分为:
有返回值、无返回值;或都可以分为有参或无参!
有返回值的方法必须在最后一句中有:
return(表达式)
4.3方法调用
方法名(【实际参数】)
注:
参数传递时形参是不能改变实际的,只有参数传递时,所传的是数据地址时,实参才会改变!
4.4递归
n!
=n*(n-1)!
(n-1)!
=(n-1)*(n-2)!
importjava.util.Scanner;//导包
publicclass递归算法{
/**
*采用递归算法求n!
*fac()=1n=1
*n*fac(n-1)n>1
*/
publicstaticvoidmain(String[]args){
递归算法cjc=new递归算法();//实例化类对像
Scannersc=newScanner(System.in);
intk=sc.nextInt();//输入
longf=cjc.fac(k);//调用方法
System.out.println(f);
}
publiclongfac(intn){//定义一个方法
if(n==1){
return1;
}else{
returnn*fac(n-1);//递归调用
}
}
}
5、数组
5.1一维数组
注:
传引用(地址传递):
数组在进行方法的参数传递的时候,传的是数组的首地址,那就意味着在调用的时候,方法里面处理的那个数组就是调用时传入的数组;
所以能够对传入的数组产生影响(比如:
数组,或者类的对象,string)
传值(值传递):
传入的值的拷贝,那么传入的变量,和方法体的变量不是一回事;
所以方法体不能对传入的变量产生作用(比如:
值类型intdoublecharfloat)该类型的变量,
如果能(.)出东西来,那么就是引用类型,反之则不是
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字符串变量=newString();
6.2字符串操作
6.2.1访问字符串
1.length()//提取字符串长度
intn=str.length();
2.charcharAt(intindex)//提取字符串中的第index个字符
charch=str.charAt(int3);//提取第三个字符
3.intindexOf(intch)//返回”个“在字符串中的下标
4.intindexOf(Stringstr,intindex)//返回”字符串“在字符串中从7开始出现的位置
5.substring(intindex1,intindex2)//提取出从3到8之间这一个子字符串
publicstaticvoidmain(String[]args){
Stringstr=newString("这是一个字符串操作的测试程序");
intn=str.length();//提取字符串长度
charch=str.charAt(5);//提取字符串中下标为5的字符
intn2=str.indexOf('个');//返回”个“在字符串中的下标
intn3=str.indexOf("字符串",7);//返回”字符串“在字符串中从7开始出现的位置
Stringstr2=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(objectobj)//区分大小写字符串比较
equalsIgnoreCase(Stringstr)//不区分大小写的字符串比较
compareTo(Stringstr)//比较二个字符串的大小
6.2.3数据类型转换
String.valueof(基本类型数据)
7、类和对象
什么是对象:
EVERYTHINGISOBJECT(万物皆对象)
7.1架构师的思维方式:
当你设计类的时候:
1、你设计类是由你模拟的事务决定;
2、类的属性,仅限于你需要用到的;
3、设计类的行为的时候,用第一人称的视角来思考,假如你就是那个类,那么你的行为是什么;
4、对于行为方法中不能写死的东西,可以考虑用方法的参数来传入;
5、对于方法参数和方法的返回值,不在局限于intdouble之类的基本类数据类型,而是扩展到所有你自己定义的复杂的数据类型;
6、在进行方法的设计的时候,先考虑参数,后考虑反回值;
7、在实现方法的时候,想清楚你和被你施加动作的东西,想清楚动作施加了之后你发生了什么变化,被你施加动作的东西发生了什么变化。
注意:
在对象变量中存放的是引用(地址);在简单变量中存放的是数值。
面向对象思想来源:
我们因需要描述更加复杂的现实世界,比如星际争霸的场面,需要有更多的数据类型,但是正常情况下,我们没有,我们只有int、double等等,一些简单的数据类型,所以,我们需要创建更多更复杂的数据类型。
面向对象技术,让我们能够追寻更加复杂的数据类型,来模拟我们的现实世界
面向对象和面向过程的区别:
面向对象的思维方式,不再是一开始就去想一步步的步骤,而是先创建模拟世界中间需要的复杂的数据类型
星际争霸:
先创建复杂数据类型,比如机枪兵类型,飞龙类型
创建了之后才去实现具体的过程
面向对象的好处:
1、能够帮助我们更加形象的写出人性化的程序
2、能够实现内容的封装,比如:
兵1.攻击(飞龙1)
3、能够让代码变得更加简洁,继承等面向对象的技术
4、能够让你站在巨人的肩膀上
7.2注意区分:
对象(本身)、对象的实现者、对象的调用者。
分析对象主要从方法开始。
我们通过类来看待对象,类是对象的抽象。
其次,采用面向对象方法可以使系统各部分各司其职、各尽所能。
7.3面向对象内存结构
//所有变量都是存在栈中的,只是值类型存值,而引用类型存地址
创建对象时,分两步:
第一步是在堆中开辟空间,存放该新创建的对象
第二步是在栈中开辟空间,存放是该对象在堆中的首地址
堆和栈本质上都是内存中的一段区域,他们是不同的区域,分别取名为堆和栈,
功能使用上有不同,在创建对象时,堆存储的是对象,栈存储的是对象的首地址
java中,数据类型
1、值类型(基本数据类型)数值类型:
intdoublelongfloat
非数值类型:
char
值类存储在栈里
2、引用类型:
数组,字符串,对象
引用类型存储在堆里,但是栈里有一个空间存储该引用类型的首地址
值类型和引用类型的访问效率问题:
1、值类型直接在栈中进行访问,效率最高
2、引用类型是通过访问栈中存储的对象的首地址,然后找到对应堆中地址的对象,所以引用类型的访问效率低
变量都是存在栈里的,只不是值类型的变量直存储的是值,而引用类型的变量存储的是堆中对象的首地址
定义引用类型的变量时,如果不让它引用对象,而又要初始化,那么我们一般设定为null
null表示空的意思。
null本质上就是0,低表的就是0地址,对于0地址的空间,系统是不允许占用,所以,可以统一用于表示空对旬或者说没有引用任何对象。
7.4类的声明
【修饰符】class类名【extends父类名】【implements接口名列表】{
成员变量声明部分
成员方法声明部分
}
7.5实例化对象
实例化对象:
类名对象名=new类名(形参列表);
对象使用:
对象名.成员变量名;
或
对象名.方法名(实参列表);
7.6构造方法:
1.方法名与类名相同的方法称为构造方法;
2.构造方法没有返回值,前面不能有返回值类型,也不能有void;
3.程序中不能直接调用构造方法;
4.构造方法没有返回值。
格式为:
public方法名。
5.构造方法是在对象生成的过程中自动调用,不可能利用指令去调用。
6.如果我们未给系统提供一个构造方法,那么系统会自动提供一个为空的构造方法。
一个类可以构造多个构造方法,但多个构造方法的参数表一定不同,参数顺序不同即属于不同的构造方法:
publicstudent(stringname,inta){
}
publicstudent(inta,stringname){
}
8、类的封装
8.1访问权限
Java中共有四种访问权限:
public(公有的)、protected(受保护的)、缺省的和private(私有的)
访问权限
权限修饰符
本类
本类所在的包
其他包中的子类
其他包中的非子类
Public
√
√
√
√
Protected
√
√
√
—
缺省
√
√
—
—
Private
√
—
—
—
8.2类成员
类名.类成员变量名
或
对象名.类成员变量名
或
类名.类成员方法名()
或
对象名.类成员方法名()
类成员是属于类的,类成员需要使用static(静态的)修饰,类成员也称为静态成员。
类成员包括类成员变量和方法。
通过类名可以直接访问类成员变量、调用类成员方法即使没有创建对象,也可以引用类成员。
类成员也可以通过对象名引用。
publicclass类成员变量{
Stringname;//实例成员变量
Stringsex;//实例成员变量
staticintcount=0;//类成员变量
publicstaticvoidmain(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方法
1、类中:
(调用自己的)
在本类中,如果需要访问自己的属性,一般情况下直接调用属性来访问;但在写构造方法的时候,最好要用自己封装的set属性方法来完成参数的初始化。
2、类外:
(调用别人的)
类中间调用其他的类的属性的时候,那么如果对方的属性是非公共的,那么只能通过对方提供的公共的get或set方法来实现访问。
8.5数学函数类方法
Math.方法名()
Sin(doublex)
Cos(doublex)
Log(doublex)//返回X的自然对数
exp(doublex)//返回E的X次方
abs(doublex)//返回X的绝对值
max(doublex,doubley)//返回X和Y中的较大值
sqrt(doublex)//返回X的平方根
random(doublex)//返回[0,1]区间内的随机数
pow(doublex,doubley)//返回y的x次方法
9、类的继承
9.1继承的实现
9.1.1定义子类
【修饰符】class类名extends父类名{
成员变量声名部分
成员