java，

java，

第一节八大数据类型
整型
1个字节占8位
1.byte 1字节 -128到127
2.short 2字节 -32768到32767
3.int 4字节 正负20亿左右 用的最多
4.long 8字节 特别大，当int不够用的时候，才会使用long

字符型
5.char 占用2个字符，采用的是Unicode编码格式，支持中文

浮点型
6.float 4字节 单精度
7.double 8字节 双精度 用的最多

布尔型
8.boolean 有两种方式 true真 false假


第二节：变量和常量
1.java的变量
变量：可以改变的量
命名规则：遵循标示符命名规则
尽量使用有意义的单词
一般首字母小写


成绩：score 身高：height
汤姆的成绩：scoreOfTom

int speed；
boolean flag；

2.java的常量
常量：值不能改变
定义常量：使用final关键字
习惯上常量都使用大写


第三节：数据类型转换
1.自动转换
目的类型比原来的类型要大
两种类型是相互兼容的
byte-short
short-int
char-int
int-long
int-double
float-double
如果两个数中有一个为double类型，那么另一个也被转换为double类型，结果为double类型
否则，两个数中有一个是float类型，那么另一个也被转换为float类型
否则，如果两个操作数中有一个long类型，另一个也被转换为long类型
否则，两个数都被转换为int类型
2.强制类型转换
浮点型转给整型：把小数给截去，保留整数位
长的整型赋给短的整型：去位
int 4个字节 32位
byte 1个字节 8位


第四节：赋值与初始化
1.赋值
赋值：是给变量制定一个值或者是改变一个变量的值
int speed=20；
variable=expression；//变量类型 变量名=表达式

2.初始化
局部变量：必须显示的进行初始化
实例变量和类变量：编译器可以自动对他们进行初始化
aBoolean=false
achar=
abyte=0
ashort=0
aint=0
along=0
afloat=0.0
adouble=0.0


第五节：初识字符串
1、字符串变量
String类
“Hello World”
“this is a String”
2、字符串的连接
可以用+来连接两个字符串，+在这里是一个连接运算符

转义字符：
每个转义字符都是由两个符号组成，但是编译器把他当成一个字符
\n 换行符 另起一行，光标移动到下一行的开始处
\t 制表符
\r 回车符 把光标移动到本行的开始处


第六节：深入理解字符串
1、字符串处理
求子串：hello world（hello是子串 world是子串 e是子串 wor是子串 想取出字符串的哪一个部分，哪一个部分就是子串）
package com.java1995;

public class TestString {

public static void main(String[] args) {
// TODO Auto-generated method stub
String str="helloworld";//先定义一个字符串
//5<=n<9
//str=str.substring(5, 10);//substring是求子串的符号，数字代表下标，从0开始数，赋值给str,下标前闭后开，包含5不包含9
str=str.substring(0, 5);
System.out.println(str);
测试字符串是否相等：equals
Object equals：比较内存地址
String equals：比较内容 不管地址
1、寄存器
2、栈
3、堆* java中的对象，都是在堆中进行分配，通过new的对象，都是在堆中分配的
4、静态存储区
5、常量存储区*final static就是常量，就是不能改变的量，只要是赋值了，就不能改变了 String常量池
6、其他存储区
API 1.6
字符串的编辑
字符串的内容是不会改变的，改变的是引用


+加法运算
-减法
*乘法
/除法
%取模
++自加运算
--自减运算
+=加法赋值
-=
*=
/=
%=
第七节：基本算术符与模运算符
1、基本算术运算符

2、模运算符
%是求两个整除相除的余数，
通常用于整型类型，用于浮点型计算结果不是很准确，在货币这一类精度高的运算需要使用BigDecimal类型


第八节：算术赋值运算符与自增自减运算符
1、算术运算符
i=i+5；
java中i+=5；称为算术赋值运算符
i-=5
i*=5
i/=5

2、自增自减运算符
i=i+1;i+=1;i++
i=i-1;i+=1;i--

++i先加再用
i++先用再加
自减运算符同理

第九节：关系运算符、逻辑运算符与三元运算符
1、关系运算符
返回值是boolean，一般用于判断语句当中
==等于 ！=不等于 >大于 <小于 >=大于等于 <=小于等于

2、逻辑运算符
&逻辑与 &&短路与
|逻辑或 ||短路或
！逻辑非
与运算符：所有条件都为真，则结果才为真，只要有一个假，结果就是假
boolean b；
b=condtion1&condition2；//先求的1,2,的值，然后进行判断
b=condition1&&condition2；//首先对condition1进行判断，如果为真，再判断condition2，如果condition1为假，则不再对conditio2进行判断


或运算符：只要有一个条件为真，结果就是真，所有条件都为假，结果才是假

3.三元运算符
int i,k;
i=-5;
k=i>=0?i:-i;
System.out.println(k);

4、运算符的优先级
（）把优先运算的内容放入括号中


第九节：流程控制之选择结构
1、if语句
一般的形式：if（条件）{
//语句块1
}else{
//语句块2
}
条件：可以使boolean类型的值，也可以是boolean类型的变量，也可以是返回值为boolean类型的表达式
嵌套if语句
if（条件1）{
//语句块1
if（条件2）{
//语句块2
}else{
//语句块3

}
}else{
//语句块4
}
2、switch语句

switch(表达式）{
case value1：//程序语句
break；
case value2：//程序语句
break；
case value3：//程序语句
break；
case value4：//程序语句
break；
default：//程序语句
}
表达式类型：byte short int char String（java7之后才出现）
Value值必须和表达式类型一致，或者兼容那个，不能出现重复的Value值


第十节：流程控制之循环结构
1、while结构
while（条件）{
//循环语句
}
条件可以是boolean类型的值、变量、和表达式，还可以是一个结果为boolean类型值的方法，
do-while：当我们需要循环至少执行一次时，即使表达式的值为false，do-while也可以执行一次，但是while是不能执行的。
do{
//循环内容
}while（条件）
2、for循环
for（初始化；条件判断；迭代运算）{
//循环语句
}
条件：必须是boolean表达式
执行过程：先初始化-条件判断-条件为真，则-循环-进行迭代-初始化
条件为假，则直接跳出循环，执行后面的语句


第十二节：流程控制之break、contiue、return
1、break语句
break：强制当前循环终止
数组：/数组：就是数据的集合
一般在很多种语言里，数组通常用[]表示，在java中也不例外。
int[] a = { 1, 2, 3 };
//注意上面表示的就是java数组，在数组名之前用[]。后面的集合用{}
String[] b = { "1", "2", "3" };
以上是字符串数组。
在java中，数组一般的操作方式为：
1、遍历(这个词经常与for循环有关)
2、克隆
a[4] = 10;//此处注意:在java语言中数组的长度是固定的，如果需要追加可用list等代替
for( int i = 0 ; i < a.length; i++ ){
System.out.println( a[i] + "==" + b[i] );
}
数组总结：数组经常用，频次仅次于main函数。 构造函数
所谓构造函数：就是一旦类被实例化成对象后，立即会调用的函数
特点：其实就是跟类名相同的函数
每一个类都会有构造函数，如果开发者没有添加，系统会默认加一个函数
如：Dog(){}
拓展：析构函数:其实就是在对象即将销毁的时候，会去调用的函数。
构造函数用处：对象一旦创建就需要加载的函数
封装基础
封装主要目的：为了类成员变量，实例变量的安全考虑
封装一般用法：主要就是set / get
在开发语言中，一般set 写为setA(属性名)，一般get写为 getA(属性名)
因为在设置中的时候，我可以根据自己行为的逻辑加上一定的判断条件，所以安全。
由于在设置的时候还是可以 huang.age,因为需要加入一个私有的修饰符，private
private: 只有本类才能够使用,一旦用private，需要getAge才能返回属性值
重载
重载：用于函数之间，函数名相同但是参数不相同
如：重载构造函数。具体调用哪一个，按照实例化时传参表现决定
类一旦实例化以后就会找到符合参数的构造函数。一旦找到就会自动调用
构造代码块: { } 一般在所有的构造器之前调用。
使用场景：一般用于众多对象都需要使用的相同的物件或者设置可以在代码块中设置。
this: 代表本类/本对象中的设置。一般用于当输入参数与类成员变量重名使用。
自动生成Getter/Setter： shift + alt + s 。选择 Getter与Setter
设计模式 - 单例设计模式
设计模式: 前人总结出的行之有效的架构模式,使用过后能快速解决某一些特定的应用场景.
单例模式: 一旦实例化过后就会有一个对象,但是每次调用就只会有一个对象.
懒汉式: 一般写法为:
private Person(){}
private static Person p;
private static Person getInstance(){
if( p == null ){
p = new Person();
}
return p;
}

懒汉式:一般在高并发下CPU的处理时间片会在判断中遇到问题
因为在多线程下是有可能做不到对象的唯一的,因此需要用到加锁

饿汉式: 一般写法为:
private Person(){}
private static Person p = new Person();
private static Person getInstance(){
return p;
}

工业上,常用饿汉式写法.
etc: 静态技术
static：一般作用于 类的成员变量以及函数
static的作用为：一旦成员变量申明了是静态，那么这个变量不需要实例化，直接通过类引用
static修饰符优势：一旦申明了那么这个变量就不需要再重新设置值，直接可以通过类去获取这个值。
static的问题：
1、一旦申明了那么这个变量就常驻分享区，也就是说还没有实例化就开始有这个static变量。
2、静态函数只能使用静态的变量。因为该函数不需要实例化可以直接通过类加载。

static 静态代码块 static{}
静态代码块: 优先于所有构造函数以及代码块,当类被调用的时候,默认调用的代码块.

注意：在main函数里面，JVM只会去调用一个叫String[]数组输入参数的main函数。其他函数认为只是普通的static函数
内存中的流程步骤：
1、因为new用到Teacher.class 所以会找到Teacher.class 文件并加载到内存中
2、执行该类中的static代码块，如果有的话给Teacher.class类进行初始化
3、在堆内存中开辟空间，分配内存地址
4、在堆内存中建立对象的特有的属性，并进行默认的初始化
5、对属性进行显示初始化（显示就是给变量进行赋初始值）
6、对对象进行构造代码块初始化
7、对对象进行构造函数初始化，
8、将内存地址复制给P变量
继承
继承:其实就是2个类之间的关系,由子类去继承父类,然后可以使用父类的所有的属性以及行为.
继承的优点:
1、子类继承父类，可以使用父类的属性
2、子类继承父类，可以使用父类的函数
3、子类继承父类，但是如果子类有相同名字以及返回值和参数的函数，那就优先调用子类的，这叫做覆盖或者重写
4: 一旦父类有构造函数,那么会调用去调用父类的
5: 如果子类也有构造函数,会优先去调用父类的构造函数

继承(二)
继承注意事项：
1、继承：子类继承父类，使用父类属性和函数。
2、继承在java中，不能多继承，但不代表不能多重继承。
3、一旦发生多重继承，先使用父类的，如果父类没有，使用父类的父类的。
4、超类和基类一般表示就是最开始的类，祖宗。

关联(普通朋友)、聚合(好朋友)、组合(基本一起死)

关联：一般是指 A类 和 B类只是一种普通的关系约束，例如：行为之间相互使用，但是并不影响各自的情况
聚合：一般是指 A类和B类，是一种整体与个体的关系，如：汽车和轮子的关系，但是少了轮子，它还叫汽车。
组合:一般是指 A类和B类，有一种与生俱来的关系，也就是刚开始2个对象就已经存在，一旦一个发生意外，那么另一个也即将销毁。

final: 也是一种修饰符。可以作用于：函数、变量、类.
final作用于类的时候，一般表示该类没有子类的情况下使用。
一旦作用于类，就不能就被继承。如：final class Person(){}

final作用于函数的时候.那么这个函数就不能被子类重写。
如： final void run(){}

final作用于变量的时候，一般说明这个变量只能赋值一次，一旦赋值就不能再改了。
如： final int a = 10; //在java中，一般这种表现形式为常量。
final 的命名方式有所讲究：一般为 final int A = 10; final float P_I = 10f

抽象(abstract)：修饰符的一种
抽象也可以修饰类，方法

1、抽象类里可有抽象方法。
2、一定定义了抽象方法，那么其子类必然需要实现父类的抽象方法。
3、抽象类中的所有的抽象方法，在子类中都必须实现
4、抽象方法一定被定义，那么肯定这个类也是抽象类。 抽象类里可以没有抽象方法但是抽象方法必须在抽象类里。
5、抽象方法本身不负责具体实现，由其子类负责具体实现。
6、抽象类本身不能被实例化。
7、abstract不能与final在一起，因为final是没有子类的，而abstract往往作用于父类，所以不能一起修饰
8、abstract不能与static与private在一起。
9、抽象一般用于申明一些固定的方法，具体实现需要到子类


接口:

接口：接口就是一组规范
接口：就是一旦遵守这组规范，你就必须要实现这些行为。
接口：一般与implements搭配使用，一个是接口，一个是实现。
接口：用的是interface关键字。
interface 接口名{
属性 / 行为
}
在interface内部每个属性都默认添加：
public static final int PI = 1
如果没有，那是系统默认添加
在interface内部每个函数都会加public
public void run()

因此，在接口中，所有的属性与函数都需要加public
因为，这些接口里的行为都需要实现。

在某种层次理解，接口就是加强版抽象。因为：
1、抽象类里不需要一定要有抽象函数。因此继承抽象，不需要一定实现非抽象方法。
2、但是接口一旦实现，那接口内部所有的函数，都需要都实现。
3、因此就相当于在抽象类内部，所有的属性都是final属性，所有函数都是抽象函数。

抽象与接口的区别：
1、抽象作用于类，一般都会有子类。
2、接口一般作用于函数。
3、抽象类只能单继承。接口也多实现,也能多继承(不推荐)。
4、抽象可以有方法体，但是接口没有。
5、实现接口必须要加入修饰符 public

为什么要有接口？
1、接口就是规范，定义实现这个事物标准
2、如果多个类去实现同一个接口里的方法(而不去写接口的话)，
是不知道这些行为属于同一类型的。
3、统一标准的目的就是为了让所有事物知道这个是“做什么”
，但是具体不用知道“怎么做”

多态
面向对象的三大特性：
封装(解耦、安全) 、继承(提升代码复用性)、多态(解耦)
多态：父类的引用指向子类的对象
Son son = new Son();
Father son1 = new Son();

多态的前提：
1、肯定会有继承。
2、肯定会有重写
3、肯定是父类去表示子类

多态的好处：
1、多种多态表示一个对象
2、当使用父类的形态表示子类的行为的时候，是可以减少代码冗余的。
3、多态有很好的可扩展性

多态的特性(非静态函数)：
1、编译的时候一般是找到左边的引用类型方法
2、运行的时候一版是找到右边的对象类型方法

Father son1 = new Son();
son1(因为Father所以在编译时检测Father类是否有sleep函数).sleep()(如果有这个函数，那么在运行右边的也就是Son子类的对象函数);

多态的特性(静态函数):
1、优先处理本类的静态函数

转型一般发生在继承的基础上：
1、必须有子类和父类
2、转型说到底还是子类的形态的转变。
注意：
1、转型发生时，如果这个对象是父类，
那么转型不可发生

多态就是父类的引用指向子类。
其实真实的内存地址是子类
子类不能去表示一个父类

object类是所有类的超类，也叫基类。
每一个类不管有多少子类，其实默认都是有一个super
其实是去调用超类Object
Object类有2个需要注意的函数(现阶段)：
1、equals() 判断两个object是否相等，与==有区别
2、clone() 克隆复制一个对象
内部类；分为普通内部类，静态内部类，方法内部类，静态内部类
//普通内部类主要区别就在于属性能否公开访问。
//2个类存在的一般情况：
/*1、如果一个类需要访问另一个的属性
a:实例化另一个类设置其属性
b:设置这个属性为静态，直接用类型使用

2、在内部类中，如果内部类需要访问外部类，
在以下情况是直接访问。
外部类的属性和方法都可以被内部类访问
内部类的属性和方法都可以被外部类访问

普通内部类，一般如果需要在其他类的函数里访问内部类函数，需要通过外部类实例化后访问
比如：人的手机，你需要拥有人这个对象以后才能访问
Animal.Dog dog1 = new Animal().new Dog();
dog1.run();

* 静态内部类，需要在内部类的class前面修饰为static。
* static的特性有：
* 1、内部类函数如果需要访问外部类的属性，那么这个外部类的属性一定要是static的
* 2、如果内部类是静态的，那么在其他类访问的时候，可以直接通过外部类.内部类访问。
*
* Animal.Cat cat = new Animal.Cat();
cat.run();

* 方法内部类，需要在方法内部添加class
* 方法内部类的特性有：
* 1、方法内部类一般可以作用于方法或者代码块中。
* 2、方法内部类一般只对方法内部负责。
* 3、任何在方法外部的类或者方法都无法实例化该内部类的对象
* 4、任何在方法外部的类或者方法都无法使用该内部类的方法
* 5、任何方法内部类不允许加上修饰符。
*
* 匿名内部类，在方法内部加入实例化操作.
* 匿名内部类的特性有：
* 1、匿名内部类是没有类名的，因此不能使用构造函数
* 2、在整个使用过程中匿名内部类只能够使用一次
*/