基础
1.变量，数据类型，运算符
变量：
声明变量
数据类型 变量名;
变量赋值（初始化）
变量名 = 表达式;
使用变量
System.out.println(变量名);
int age = 10;//int age; age = 10;
System.out.println(age);
age = age + 1;//age增加1
数据类型：
基本类型（8种）
整型：
byte: 1字节
short：2字节
int：4字节（常用） -2的31次方~2的31次方-1
long：8字节
3：int
3L或3l:long
浮点型：
float：4字节，单精度浮点型
double：8字节，双进度浮点型（常用）
2.0：double
2.1：double
2.1f或2.1F:float
字符型：
char:2字节
采用Unicode16编码
char c1 = 'a';
System.out.println(c1);//输出a
'a', 'A', '我' , ' ':字符常量
'\n','\t','\\' : \表示转义字符
布尔类型：
boolean:1字节，值：true,false
引用类型
数组，对象。。。
基本类型中的数值型类型转换（除了boolean）
byte,short,char < int < long < float < double
自动类型转换
1.小的可以直接赋给大的
int a = 2;
double b = a;//√
float c = b;//×
2.int常量 可以直接赋给byte,short,char，只要不超过其表示范围
byte b1 = 1;
3.byte,short,char在运算时自动转换成int运算
byte b1 = 1;
byte b2 = 2;
byte b3 = b1 + b2;//×
4.在不同类型运算时，小的自动转换成大的，表达式结果取类型最大的
double d = 1+2+2.0;//√
强制类型转换
大的赋给小的
int a = 2;
double b = a;//√
float c = (float)b;//√
byte b1 = 1;
byte b2 = 2;
byte b3 = (byte)(b1 + b2);//√
运算符
算术运算符：+，-，*，/, ++, --
5/2:2
5.0/2:2.5
赋值运算符：=, +=, -=,...
关系运算符：>,>=,<,<=,==,!=
关系表达式结果是布尔类型
= vs == :注意区分
逻辑运算符：
&&，&，||，|，！，^
常用：&&(与)，||(或)，！(非)
逻辑表达式结果是布尔类型
&& vs &
&&:短路与，如果第一个条件可以判断出结果，则不再执行第二个条件
第一个条件不成立，则不再执行第二个条件
&：每个条件都会判断
推荐使用&&
条件结构
if条件结构
if(条件){
条件成立执行的代码;
}
if(条件){
条件成立执行的代码;
}else{
条件不成立执行的代码;
}
if(条件1){
条件1成立执行的代码;
}else if(条件2){
条件2成立执行的代码;(条件1不成立)
}else if(条件n){
上面条件都不成立，条件n成立执行的代码
}else{
条件不成立执行的代码;
}
if(){
//条件嵌套
if(){
}else{
}
}
switch条件结构
switch(表达式){
case 常量1：
代码;
break;
case 常量2：
代码;
break;
...
default:
代码;
break;
}
表达式结果的类型：
整型(除了long),jdk1.7以上String,枚举类型
计算表达式结果，判断与哪个分支的常量相等，执行哪个分支，直到遇到break结束。
如果所有的分支都不符合，执行default,可以省略default
if条件 vs switch条件
所有的条件都可以用if来实现
单点值的条件可以用switch来实现
对于单点值判断：如果有多个
建议使用switch,效率更高
剩下的使用if条件
switch表达式只要计算一次，判断和哪个分支匹配即可
if条件，表达式要计算多次
循环结构
for循环
for(1.循环变量的初始化;2.循环条件;4.循环变量的改变){
3.循环体：每次循环执行的操作
}
执行流程：
1.循环变量初始化
2.条件判断，成立
3.循环体
4.循环变量的改变
2.
3.
4.
...
直到2判断不成立，循环结束
for(int i=1; i<=10; i++){//i从1到10，每次增加1
System.out.println(i);
}
//求1~50之间所有偶数的和
int sum = 0;
for(int i=2; i<=50; i+=2){
sum += i;
}
System.out.println(sum);
//分析： sum=0
i=2 sum+=i; 2
i=4 sum+=i; 6
i=6 sum+=i; 12
while循环
while(条件){
循环体
}
判断条件，成立执行循环体
判断条件，成立执行循环体
直到判断条件不成立，结束循环
//求1~50之间所有偶数的和
int i=2;
int sum = 0;
while(i<=50){
sum += i;
i += 2;
}
System.out.println(sum);
do-while循环
do{
循环体
}while(条件);
执行循环体
判断条件，成立执行循环体
判断条件，成立执行循环体
直到判断条件不成立，结束循环
while和do-while的区别
while:循环体最少可能执行0次
do-while:循环体最少可能执行1次
数组
对一组数据进行操作
特点：
元素类型相同
长度固定
动态语法：适合在创建数组时，值未知
1.声明数组
元素类型[] 数组变量名;
2.创建数组对象
数组变量名 = new 元素类型[数组长度];
3.使用数组
赋值：数组变量名[下标] = 值;
取值：数组变量名[下标]
长度：数组变量名.length
下标：从0开始，到数组长度-1，不能越界，否则运行出错
ArrayIndexOutOfBoundsException
静态语法：适合在创建数组时，值已知
声明，创建，赋值一步完成
1)元素类型[] 数组变量名 = {值1,值2,...};
2)元素类型[] 数组变量名 = new 元素类型[]{值1,值2,...};
对数组常用操作：
求和，求平均，求最大，求最小，排序，查找一个指定的元素
面向对象编程（OOP）：Object Oriented Programming
对象+对象+对象+...
银行账户：
属性：
余额
账号
密码
个人信息等等。。。
方法：查询余额
转账
取款
存款
...
我们作为对象的使用者，使用对象的功能，完成我们想要的
类
是对象的抽象
对象的模板，蓝图
代表这个类的对象是什么样的
定义类：
public class 类名{
//属性：
类型 变量名;
//方法：
修饰符 返回值类型 方法名(形参){
方法体;
}
}
对象
是类实例化的结果
先有类，再有对象
一个类可以创建多个对象
创建对象：
类名 引用变量名 = new 构造方法();
new 类名();
使用对象：
使用属性：
引用变量名.属性名
使用方法:
引用变量名.方法名(实参)
细节：
创建对象，属性如果没有显式赋值，则会进行默认的初始化
基本类型：
数值型：默认是0
布尔类型：默认是false
引用类型：默认是null(空)
数组和对象一样，元素没有显式赋值则会进行默认的初始化，同上
变量总结：
按照位置分：
局部变量：定义在方法中，代码块中
作用域：
所在的方法或代码块
从声明初始化开始到声明所在的最小{}结束位置
public class Demo{
public stataic void main(String[] args){
int a = 3;
System.out.println(a);
if(a > 2){
int b = 1;//只能在if中使用
}
}
}
属性(成员变量，字段)：定义在类中
在这个类中可以直接使用
在这个类外，需要创建对象，通过对象引用使用，对象引用变量名.属性名
按照类型分：
基本类型变量：8种
存储对应的值
引用类型变量：除了基本类型，都是引用类型，比如数组引用，对象引用等
保存对象的地址
操作对应的对象，对象必须通过它的引用变量来操作
就类似于：通过风筝的线来操控风筝
通过遥控器来操控电视
内存分析：
所有的局部变量存储在栈中，局部变量出了作用域自动销毁
new出来的对象存储在堆中，当没有任何引用指向这个对象，后面由垃圾回收器回收
OOP三大特性：
封装
把属性和方法放到类中
并且实现信息的隐藏
1）属性的隐藏，外部无法直接使用
2）方法实现细节的隐形
权限修饰符
private:私有的， 只有当前类内部可见
默认的：什么都不写 包权限，同包下可见
protected：受保护的 受保护的，同包或子类下可见
public:公开的 都可见
private<默认的<protected<public
都可以修饰属性，方法
类可以用默认的或public修饰
属性：通常是私有的，根据需要提供set和get方法
方法：通常是公开的
类： 通常是公开的
setters/getters方法
属性私有化，可以提供对应属性的set,get方法
set方法形式：
以balance为例
public void setBalance(double blance){
//当前对象的属性balance = 形参balance;
this.balance = balance;
}
get方法形式：
public double getBalance(){
return balance;
}
构造方法：
作用：创建对象时完成对象的初始化
形式：
权限修饰符 方法名(形参){
}
特点：
1.方法名和类名相同
2.没有返回值类型
调用：
在创建对象时调用
调用语法：
new 构造方法(实参)
如果类没有显式提供构造方法，则会有一个默认的构造方法
如果类已经定义了构造方法，则不再提供默认构造方法
形式：无参
public 类名(){}
类一定有构造方法
继承
学生类：
姓名，年龄，性别，学号，班级
get,set方法，学习方法，构造方法等
老师类：
姓名，年龄，性别，工号
get,set方法，工作方法，构造方法等
学生和老师都是人，有人共同的属性方法
可以抽象出人，把人共同的属性，方法定义出来
学生和老师都属于人，学生和老师都可以继承人，包含了人的属性和方法
如果某个类A可以看成B类型，可以让A继承B,A拥有了B的属性，方法
B称为父类，A称为子类
继承就像基因的继承一样，但是java只支持单继承
继承要符合is a关系，也就是子类必须可以看成是父类类型
人
学生 老师
学生和老师都可以看成是人，把不同的类型可以看成是同一个父类类型
//可以给类定义toString()方法，用来返回对象的所有属性值
public String toString(){
}
方法的重写：
子类继承父类的方法，实现需要调整，可以重写父类的方法
声明一致，修改实现，权限大于等于原来的权限
继承中的构造方法
创建子类对象，调用子类构造方法，子类构造方法中必须先调用父类的构造方法初始化父类部分，再初始化子类部分
调用：super(实参)
必须写在子类构造方法的第一行
如果没有显式调用父类构造方法，则默认调用父类无参构造方法，如果没有无参构造方法，则编译报错
super关键字：
作用1：子类中调用父类重写前的方法
super.方法名(实参)
作用2：在子类构造方法中调用父类构造方法初始化父类部分
super(实参)
必须出现在构造方法中的第一行
this关键字：当前对象的引用，可以在类内部使用
作用1：用来区分同名的属性和形参
public void setName(String name){
this.name = name;
}
作用2：在类的构造方法中调用当前类的其他构造方法
this(实参)
减少代码重复
必须出现在构造方法中的第一行
Object类：
所有类的父类
祖先类
如果类没有显式指定继承的父类，则默认继承Object
public String toString():返回对象的描述信息
默认返回包名.类名@十六进制无符号的哈希码值
建议每个类重写toString()方法，返回对象的属性值
打印对象时，对象和字符串拼接时，默认调用toString()
boolean equals(Object o):
用来判断当前对象是否和传入的对象相等
默认规则：和==一样
我们可以根据需要重写这个方法，
比如String类重写了equals()方法，当表示的是相等的字符序列时返回true
多态
父类引用可以指向子类对象, 父类引用 = 子类引用
Person p = new Student();
Student s = new Student();
Person p2 = s;
Person p3 = new Teacher();
p2.setName("tom");
引用指向对象，用来操作对象的，所有运行方法由对象决定
编译时，通过引用的类型确定是否有对应的方法
运行时，根据指向的对象的类型来决定调用哪个方法
如果子类中没有，继续找父类，已知向上找
“编译看引用，运行看对象”
父类：
人：toString()
子类：
学生：重写toString() 老师:重写toString()
可以通过人指向学生或老师
调用toString()方法时，调用的toString()方法时不同的
Person p;
p = new Student();
p.toString();
p = new Teacher();
p.toString();
效果各不相同，就是多态
多态的形式条件：
子类继承父类
重写父类的方法
父类引用指向子类对象
当通过引用调用重写的方法时，效果各不相同
多态的好处：
可以面向一组对象，用通用的代码来编程
会根据对象的类型自动调用对应对象类的方法
接口
代表一组算法
类可以实现接口，并且可以实现多个接口
关系：like a,像这样，拥有一套这样的行为
不同类型的类可以实现相同的接口
比如：人可以在水里游
船也可以在水里游
针对游泳的行为，可以通过接口指向这两种类的对象，调用游的方法，不同对象效果不同的
多态的形式条件：
子类继承父类 实现类实现接口
重写父类的方法 实现接口的方法
父类引用指向子类对象 接口引用指向实现类对象
当通过引用调用重写的方法时，效果各不相同
面向接口编程
628
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
