3.“&”“&&”的区别
3.1单&时，左边无论真假，右边都进行运算
3.2双&&时，如果左边为真，右边参与运算，如果为假，右边不参与运算
3.3“|””||”；如果为双或，左边为真，右边不参与运算
3.4“|””^”的区别：
当左右都为true，结果为false
4.位运算符：
直接二进制进行运算
运算符运算例子注意事项
<<左移3<<2=12:
3*2*2空位补0，被移除的最高位丢弃
>>右移3>>1=1:
3/2=1被移除的二进制最高位是0，右移后，空位补0，最高位是1，就补1
>>>无符号右移3>>>1=1:
3/2=1被移位的二进制最高位无论是0还是1，空位都用0来补
&与运算6&3=2任何二进制位和0进行&运算，结果都是0，和1进行&运算结果是原值
|或运算6|3=7任何二进制位和0进行|运算，运算结果是原值，和1进行运算，结果为1
^异或6^3=5任何二进制位和0进行^运算，相同为0，不相同为1
~反码~6=-7
00000110原码
11111001反码
11111001补码转换成反码
11111000反码
10000111原码-7
思考：
请用最有效的方法写出计算2乘以8的结果
三目运算符
（关系表达式）？
表达式1;表达式2；
结果条件为true，运算后的结果是表达式1
反之表达式2
举例：
获取表达式中最大的值
Intx=3,y=4,z;
Z=（x>y）?
x:
y;
语句（掌握）：
流程控制语句：
在一个程序执行过程中，各条语句的执行顺序对程序的结果又直接影响，其实是程序的流程对运行结果有直接影响，必须掌握每条语句的执行流程
1.顺序结构
概述：
是程序中最基本的流程控制，并没有特定的语句结构，按照代码的先后顺序依次执行。
开始---->语句A---->语句B---->结束
2.选择结构
2.1概述：
也被成为分支结构
2.2特点：
有特定的语法规则，代码要执行具体的逻辑运算进行判断，逻辑运算的结果有两个，所以产生选择，按照不同的选择执行不同的代码
2.3if语句
2.3.1if语句表现的三种格式
1）If（关系表达式）
/*语句体:
正常的逻辑代码*/
语句体
2）if（关系表达式）{
语句体1
}else{
语句体2
}
执行的流程：
1.判断关系表达式，看其结果是true还是false
2.如果是true执行语句体
3.如果是false不执行语句体
3）if（关系表达式）{
语句体1
}elseif（关系表达式）{
语句体2
}
……
Else{
语句体3
}
注意事项：
1.关系表达式无论是简单还是复杂，其结果都是boolean
2.If语句控制的语句如果是一条语句，大括号可以省略（一般不建议）
3.一般来说有左大括号就没有分号，有分号就没有大括号。
2.4switch语句
1.格式：
switch（表达式）{//表达式值：
byte/short/int/char
//jkd5以后加入枚举，1.7以后加入String
case值:
//和表达式进行比较的值
语句体1
break;//结束switch语句，穿透
case2:
//语句体2
break;
default:
//上面所有的语句都不匹配时，执行这行语句
//语句体n+1
break;
}
2.流程：
2.1计算表达式的值
2.2和case依次进行比较，一旦有对应的值，就会执行相应的语句
2.3如果和所有的case都不匹配，执行default这行语句
3.注意事项：
1.case后面只能是常量，不能是变量，多个case后出现的值不能相同
2.default可以省略（一般不建议），可以放在switch语句的任意位置
3.break也可以省略
3.循环结构（遍历）
循环语句的组成：
1．初始化语句：
一条或者多条语句，这些语句完成一些初始化的操作
2．判断语句：
是一个boolean类型的表达式，这个表达式能解决是否执行循环体
3．循环体语句
逻辑代码，多次要执行的语句
4.控制条件语句
在一次循环体结束后，下一次循环判断条件执行之前通过控制条件语句中的变量，使循环在合适的时候结束
3.1for循环
格式:
For（初始化语句；判断条件语句；控制条件语句）{
循环体语句}
执行流程：
1.执行初始化语句
2.执行判断语句，看其结果是true还是false
True：
继续执行
False：
循环结束
3.执行循环体语句
4.执行控制条件语句
5.回到第二步
注意事项：
1.判断条件语句是一个boolean类型
练习：
求1~100之和
求1~100之间偶数和
3.2while循环
格式：
While（判断条件语句）{
循环体语句
}
扩展格式：
初始化语句：
While（判断条件语句）{
循环体语句；
控制条件语句；
}
练习：
输出10次“helloworld”
For和while区别：
1.For针对一个范围判断进行操作
2.While适合判断次数不明确的操作
3.3do…while循环语句
1.格式：
do{
循环体语句
}while（判断条件语句）：
扩展版：
初始化语句：
Do{循环体语句;
控制条件语句；
}while（判断条件语句）
循环结构（区别和注意事项）
1.三种循环其实都可以完成同样的功能，也可以等价交换
区别：
1.do…while循环至少执行一次循环体
2.for和while循环当判断条件成立时才执行循环体语句
注意事项：
1.写程序优先考虑for循环，再考虑while循环，最后考虑do…while循环
2.For死循环：
for（；；）{
循环体语句；
}
While死循环：
while（true）{循环体语句；
}
跳转控制语句：
Break：
中断
Continue：
继续
Return：
返回
Break的使用场景：
1.在选择结构switch语句中
2.循环语句中
3.离开使用场景没有存在的意义
Break的作用：
1.跳出单层循环
2.可以跳出多层循环
2.1带标签的跳出
2.2标签名名要符合Java命名规则
Continue的使用场景：
1.循环语句中
2.离开使用场景没有存在的意义
Continue的作用：
1.单层循环对比break的区别
1.1break退出当前循环
1.2退出本次循环
Return：
关键字，功能：
结束一个方法，退出一个方法
方法：
概述：
完成特定功能的代码块，Java里面的函数指的是方法
格式：
修饰符返回值类型方法名（参数的类型参数名1，参数的类型参数名2……）
函数体：
Return返回值：
修饰符：
publicprivateprotected
返回值类型：
用于限定返回值的数据类型
方法名：
一个名称，为了便于开发者调用
参数名：
是一个变量，接受调用者传进来的参数
函数体：
完成功能的代码
Return：
结束方法以及返回方法指定类型的值
方法注意事项：
1.方法不调用不执行
2.方法与方法是平级关系，不能嵌套定义
3.方法定义时参数之间用用逗号隔开
4.方法在调用时不能传递数据类型
5.如果方法有明确的返回值，一定要有带return带回一个值
练习：
键盘录入一个数据n（1<=n<=9）输出对应的nn乘法表
键盘录入：
创建一个对象newScanner（）
要求：
输出对应的nn乘法表
两个明确：
1.确定返回值的类型：
void
2.明确参数列表：
intn
publicclasstest1{
publicstaticvoidmain（String[]args）{
/**
*键盘录入一个数据n（1<=n<=9）输出对应的nn乘法表
*需求：
输出对应的nn乘法表
两个明确：
1.确定返回值的类型：
void
2.明确参数列表：
intn
*/
//创建键盘录入对象
Scannersc=newScanner（System.in）;
//提示用户输入对应的值
System.out.println（"请输入n的值：
（1~9）"）;
//获取n
intn=sc.nextInt（）;
//封装方法，调用
printNN（n）;
}
publicstaticvoidprintNN（intn）{
for（intx=1;x<=n;x++）{
for（inty=1;y<=x;y++）{
System.out.print（y+"*"+x+"="+y*x+"\t"）;
}
System.out.println（）;
}
}
}
数组：
概述：
可以存储多个变量的容器，里面的变量的数据类型要一致
存储的数据类型：
基本数据类型，引用数据类型
格式：
1.数据类型[]数组名;
2.数据类型数组名[];
数组的初始化过程：
1.动态初始化，初始化时只指定数组的长度，由系统为数组分配初始值
格式：
数组类型[]数组名=new数据类型[数组长度]
Int[]arr=newint[3];
简介版：
int[]arr={12,22,33,44};
2.静态初始化，初始化时指定每个元素的初始值，由系统决定数组的长度
练习：
获取数组中的最大值
Int[]arr={11,22,445,576,7878};
/**
*获取数组中的最大值
*
*@authorAdministrator分析：
1.定义一个数组，并对数组中的元素进行静态初始化
*2.从数组中找任意一个元素作为参照物（一般取第一个），默认为他就是最大值3.遍历其他元素，一次和参照物进行比较，如果大就留下来，小就离开
*4.最后参照物里面保存的就是最大值
*/
publicclasstest1{
publicstaticvoidmain（String[]args）{
//定义一个数组
int[]arr={34,98,10,25,67};
//获取数组中的最大值
intmax=getMax（arr）;
//控制台打印最大值
System.out.println（"Max:
"+max）;
//获取数组中的最小值
intmin=getMin（arr）;
System.out.println（"min:
"+min）;
}
/**
*获取最小值的方法
*
*@paramarr
*@return
*/
publicstaticintgetMin（int[]arr）{
//从数组中找任意一个元素作为参照物
intmin=arr[0];
//遍历数组
for（intx=1;x//一次进行比较
if（arr[x]min=arr[x];
}
}
returnmin;
}
/**
*获取最大值的方法
*
*@paramarr
*@return
*/
publicstaticintgetMax（int[]arr）{
//从数组中找任意一个元素作为参照物
intmax=arr[0];
//遍历数组
for（intx=1;x//一次进行比较
if（arr[x]>max）{
max=arr[x];
}
}
returnmax;
}
}
面向对象：
概述：
基于面向过程的编程思想
特点：
1.是一种更符合思想习惯的一种思想
2.可以将复杂的事情简单化
3.可以将我从原来的执行者变成指挥者
面向对象开发：
不断的去创建对象，使用对象，指挥对象做事情
面向对象设计：
在管理和维护对象之间的关系
面向对象的特征：
封装：
多态：
继承：
抽象：
类与对象的关系：
属性：
该事物的描述信息
行为：
该事物能够做什么
类：
是一组相关属性和行为的集合
对象：
该事物的具体表现
举例：
类：
学生
对象：
班长，学委
Java中class描述事物
成员变量就是事物的属性
成员方法就是事物的行为
成员变量和局部变量的区别：
1.在类中的位置不同
成员变量类中方法外
局部变量方法内或者方法声明上
2.在内存的位置不同
成员变量堆内存
局部变量栈内存
3.生命周期不同
成员变量随着对象的存在而存在，对象的消失而消失
局部变量随着方法的调用而存在，方法的调用完毕而消失
4.初始化值不同
成员变量有默认的初始化值
局部变量没有默认的初始化值，必须先定义，赋值，才能使用
封装：
概述：
指隐藏对象的属性和实现细节，仅对外提供公共的访问方式
好处：
1.实现细节的隐藏
2.提高代码的复用性
3.提高安全性
原则：
1.将不需要对外提供的内容都隐藏起来
2.把属性隐藏，提供公共的方法对其访问
publicclasstest1{
//定义人的姓名
privateStringName;
//定义人的年龄
privateintAge;
publicStringgetName（）{
returnName;
}
publicvoidsetName（Stringname）{
Name=name;
}
publicintgetAge（）{
returnAge;
}
publicvoidsetAge（intage）{
Age=age;
}
}
关键字private
1.是一个权限修饰符
2.可以修饰成员（成员变量和成员方法）
3.被private修饰的成员只能在本类中才能访问
常见的应用：
1.将成员变量用private修饰
2.提供对应的getXXx（）/setXxx（）方法
关键字this
代表所在类的一个对象引用
注意：
方法被那个对象调用，this就代表那个对象
何时使用this
局部变量隐藏成员变量
构造方法
概述：
给对象的数据进行初始化；
作用：
数据传递
格式：
1.方法名和类名相同
2.没有返回值类型，连Void都没有
3.没有具体的返回值
注意事项：
1.如果你不提供构造方法，系统会默认给出
2.如果你提供构造方法，系统不会给出
3.构造方法可以重载
重载：
方法名相同，参数个数/类型不同
练习：
在Java文件中写两个类，一个是基本类，一个测试类
注意：
文件的名称和测试类一致
publicclassStudent{
//姓名
StringName;
//年龄
intAge;
//地址
Stringaddress;
//学习
publicvoidstudy（）{
System.out.println（"学生爱学习"）;
}
//吃饭
publicvoideat（）{
System.out.println（"学习累了，要吃饭"）;
}
//睡觉
publicvoidsleep（）{
System.out.println（"学习累了，要睡觉觉"）;
}
}
publicclassStudentDemo{
publicstaticvoidmain（String[]args）{
//获取student类的对象
//Students=newStudent（）;
Students=newStudent（）;
//给成员变量赋值
s.Name="林青霞";
s.Age=18;
s.address="寿光";
//输出语句
System.out.println（s.Name+"---"+s.Age+"----"+s.address）;
s.study（）;
s.eat（）;
s.sleep（）;
}
}
Static关键字
概述：
可以修饰成员变量和成员方法
特点：
1.随着类的加载而加载
2.优先于对象存在
3.被类的所有对象共享（判断是否使用静态关键字的条件）
4.可以通过类名调用
注意事项：
1.在静态方法中没有this关键字
2.静态方法只能访问静态的成员变量和静态的成员方法（静态只能访问静态）
所属不同：
静态变量：
属于类，也成为类变量
成员变量：
属于对象，也成为实例对象（对象变量）
内存中的位置不同：
静态变量：
存储于方法区的静态区
成员变量：
存储于堆内存中
调用不同：
静态变量：
可以通过类名直接调用，也可以通过对象
成员变量：
只能通过对象调用
继承（掌握）：
概述：
在多个类中存在相同行为和属性时，将这些属性抽取到单独的类中，那么多个类无需再定义这些属性和行为，只要通过继承类即可
通过extents关键字来实现与类的继承
例如：
Class
升级会员 