第一周博客

一.注释

1.单行注释：使用“//”开头，“//”后面的单行内容均为注释。

2.多行注释：以“/*”开头，以“*/”结尾，在“/*”和“*/”之间的内容均为注释。多行注释不能嵌套使用！！！

3.文档注释：以“/**”开头，以“**/”结尾。

二.标识符规则

1.标识符必须以字母下划线_、美元符号$开头。

2..标识符其它部分可以是字母、下划线“_”、美元符“$”和数字的任意组合。

3.Java标识符大小写敏感，且长度无限制。

4.标识符不可以是Java的关键字。

5.标识符的使用规范
表示类名的标识符：每个单词的首字母大写，如Man,GoodMan

表示方法和变量的标识符：第一个单词小写，从第二个单词开始首字母大写，我们称之为“驼峰原则”，如eat(),eatFood()

三.Java的关键保留字

 四.变量

1.·变量的声明格式为：
 type va初始rName[=value][,varName[=value]...];

 //[]中的内容为可选项，即可有可无

数据类型 变量名 [=值][，变量名 [=初始值].]；

2.每个变量都有类型，类型可以是基本类型，也可以是引用类型。

3.变量名必须是合法的标识符

4.变量声明是一条完整的语句，因此每一个声明都必须以分号结束

5.局部变量(local variable)：方法或语句块内部定义的变量。生命周期是从声明位置开始到到方法或语句块执行完毕为止。局部变量在使用前必须先声明、初始化(赋初值)再使用。

6.成员变量(也叫实例变量 member variable)：方法外部、类的内部定义的变量。从属于对象，生命周期伴随对象始终。如果不自行初始化，它会自动初始化成该类型的默认初始值。
表2-3 实例变量的默认初始值
数据类型          实始值
int                        0
double                0.0
char                ' \u0000'
boolean             false

7.静态变量（类变量 static variable）
使用static定义。从属于类，生命周期伴随类始终，从类加载到卸载。如果不自行初始化，与成员变量相同会自动初始化成该类型的默认初始值。

五.常量

1.常量通常指的是一个固定的值，例如：1、2、3、’a’、’b’、true、false、”helloWorld
”等。在Java语言中，主要是利用关键字final来定义一个常量。 常量一旦被初始化后不能再更改其值。

2.变量和常量命名规范
类成员变量：首字母小写和驼峰原则：monthSalary
局部变量：首字母小写和驼峰原则
常量：大写字母和下划线：MAXgVALUE
类名：首字母大写和驼峰原则：Man,GoodMan
方法名：首字母小写和驼峰原则：run(),runRun)

六.基本数据类型

1.数值型 - byte、 short、int、long、float、double 

字符型(文本型)-char

布尔型-boolean

2.byte——1字节

short——2字节

int——4字节

long——8字节

3.十进制整数，如：99，-500，0

八进制整数，要求以0开头，如：015

十六进制数，要求Ox或OX开头，如：Ox15

二进制数，要求0b或0B开头，如：0b01110011

4.float类型的数值有一个后缀F或者f，没有后缀F/f的浮点数值默认为double类型。也可以在浮点数值后添加后缀D或者d，以明确其为double类型。

5.字符型：'A'表示一个字符，"A"表示一个字符串。

6.boolean类型：boolean类型有两个常量值，true和false 在内存中占一位（不是一个字节），不可以使用0或非0的整数替代true和false，这点和C语言不同。boolean类型用来判断逻辑条件，一般用于程序充程控制。

七.算术运算符·

1.

 2.如果两个操作数有一个为Long，则结果也为long。
没有long时，结果为int。即使操作数全为short，byte，结果也是int。
如果两个操作数有一个为double，则结果为double。
只有两个操作数都是float，则结果才为float。

3.取模运算：其操作数可以为浮点数，一般使用整数，结果是“余数” ，“余数”符号和左边操作数相同，如：7%3=1，-7%3=-1，7%-3=1。I
算术运算符中++，--属于一元运算符，该类运算符只需要一个操作数。

八.赋值运算符

 九.关系运算符

1.

2. =是赋值运算符，而真正的判断两个操作数是否相等的运算符是==。
    ==、！=是所有(基本和引用)数据类型都可以使用
    >、>=、<、<=仅针对数值类型( byte/short/int/long,float/double。以及char)

十.逻辑运算符

 十一.位运算符

1.

十二.运算符

1.字符串连接符：“+”运算符两侧的操作数中只要有一个是字符串string类型，系统就会自动将另一个操作数转化为字符串然后进行连接。

2.条件运算符：x?y:z

其中x为boolean类型表达式，先计算x的值，若为true,则整个运算的结果为表达式y的值，否则整个运算结果为表达式z的值

3.运算符优先级

十三.类型转换

1. 自动类型转换

备注：实线代表无数据丢失的自动类型转换，虚线表示在转换时可能有精度的缺失

可以将整型常量直接赋值给byte、short、char等类型变量，而不需要进行强制类型转换，只要不超出其表数范围即可。

2.强制类型转换

十四.语句

1.if单选择结构语句

语法：if（布尔表达式）{

语句块

}

2.if_else双选择结构语句

语法：if（布尔表达式）{

语句块1；

}else{

语句块2；

}

3.if_else if_else多选择结构语句

语法：if（布尔表达式1）{

语句块1；

}else if（布尔表达式2）{

语句块2；

}……

else if（布尔表达式n）{

语句块n；

}else {

语句块n+1；

}

4.switch多选择结构

 5.while循环

语法：while(布尔表达式）{

循环体;

}

6.do while 循环

语法：do{

循环体；

}while（布尔表达式）；

7.for循环

8.嵌套循环

9.break语句

10.continue语句

十五.方法的定义

1.方法的声明格式：

         [修饰符1  修饰符2  …..] 返回值类型  方法名( 形式参数列表 ){

                   Java 语句;… … …

}

例如： public static int add(int a,int b){

　　int sum=a+b;

　　return sum;

}
2.形式参数：在方法被调用时用于接收外界输入的数据。
   实参：调用方法时实际传给方法的数据。
   返回值：方法在执行完毕后返回给调用它的环境的数据。
   返回值类型：事先约定的返回值的数据类型，无返回值，必须给出返回类型viod。

3.Java语言中使用下述形式调用方法：对象名.方法名(实参列表)

　例如上述方法调用为： int sum=add(5,3);

4..实参的数目、数据类型和次序必须和所调用方法声明的形式列表匹配。

十六.方法的重载

1.方法的重载的规则:
   方法名称必须相同
   参数列表必须不同（个数不同、或类型不同、或参数多类型的排列顺序不同)三者至少一个不同
   方法的返回类型可以相同也可以不相同
   仅仅返回类型不同不足以成为方法的重载

2.构成方法重载的条件：

不同的含义：形参类型，形参个数，形参顺序不同

只有返回值不同不构成方法的重载

例：int a(String str){}与void a(String str){}

3.不构成方法重载：

只有形参的名称不同，不构成方法的重载

例：int a(String str){}与int a(String str){}

十七.递归与迭代

1.递归是重复调用函数自身实现循环，迭代是函数内某段代码实现循环。

2.迭代与普通循环的区别是：循环代码中参与运算的变量同时是保存结果的变量，当前保存的结果作为下一次循环计算的初始值。递归循环中，遇到满足终止条件的情况时逐层返回来结束。迭代则使用计数器结束循环。

十八.面向过程和面向对象

1.区别：可以拿生活中的实例来理解面向过程与面向对象，例如五子棋，面向过程的设计思路就是首先分析问题的步骤：1、开始游戏，2、黑子先走，3、绘制画面，4、判断输赢，5、轮到白子，6、绘制画面，7、判断输赢，8、返回步骤2，9、输出最后结果。把上面每个步骤用不同的方法来实现。

如果是面向对象的设计思想来解决问题。面向对象的设计则是从另外的思路来解决问题。整个五子棋可以分为1、黑白双方，这两方的行为是一模一样的，2、棋盘系统，负责绘制画面，3、规则系统，负责判定诸如犯规、输赢等。第一类对象（玩家对象）负责接受用户输入，并告知第二类对象（棋盘对象）棋子布局的变化，棋盘对象接收到了棋子的变化就要负责在屏幕上面显示出这种变化，同时利用第三类对象（规则系统）来对棋局进行判定。

可以明显地看出，面向对象是以功能来划分问题，而不是步骤。同样是绘制棋局，这样的行为在面向过程的设计中分散在了多个步骤中，很可能出现不同的绘制版本，因为通常设计人员会考虑到实际情况进行各种各样的简化。而面向对象的设计中，绘图只可能在棋盘对象中出现，从而保证了绘图的统一。

十九.对象和类

1.什么是对象：

（1）对象是一种具体的概念。
（2）对象：对象是人们要进行研究的任何事物，它不仅能表示具体的事物，还能表示抽象的规则、计划或事件。对象实现了数据和操作的结合，使数据和操作封装于对象的统一体中。

2.类与对象的关系就如模具和铸件的关系，类的实例化的结果就是对象，而对象的抽象就是类，类描述了一组有相同特性（属性）和相同行为的对象。

3.典型类的写法与调用：

①class A{…}
②public class B{…}

类的构成：属性+方法+主方法

注意，定义类时，类名后面不需加圆括号；
而定义方法需要在方法名后加上括号

当一个程序中同时出现以上两个类时，需要将class定义的类放在public class定义的类上面

且类中定义的方法，需要包含在类内部，主方法也需要包含在类内部

二十.内存分析

1.堆区:
（1）.存储的全部是对象，每个对象都包含一个与之对应的class的信息。(class的目的是得到操作指令)
（2）.jvm只有一个堆区(heap)被所有线程共享，堆中不存放基本类型和对象引用，只存放对象本身.
（3）.一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。

2.栈区:
（1）.每个线程包含一个栈区，栈中只保存基础数据类型的对象和自定义对象的引用(不是对象)，对象都存放在堆区中
（2）.每个栈中的数据(原始类型和对象引用)都是私有的，其他栈不能访问。
（3）.栈分为3个部分：基本类型变量区、执行环境上下文、操作指令区(存放操作指令)。
（4）.由编译器自动分配释放 ，存放函数的参数值，局部变量的值等．

3.静态区/方法区:
（1）.方法区又叫静态区，跟堆一样，被所有的线程共享。方法区包含所有的class和static变量。
（2）.方法区中包含的都是在整个程序中永远唯一的元素，如class，static变量。

（3）.全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域， 未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。

4.  栈(stack)：（1）.为每个方法分配一个栈帧，栈帧之间不共享 
                      （2）.存放局部变量：基本数据类型和对象的引用 
    堆(head)：（1）.存放对象 
                      （2）.被所有线程共享 
    方法区(methodArea)：（1）.被所有线程共享 
                                       （2）.存放整个程序中永远唯一的元素：class（字节码指令），static（静态变量）和字符串常量

二十一.构造方法

构造方法的重载与方法的重载相同，都是方法名相同而方法参数顺序，类型或个数不同。多个对象的初始化需要创建多个构造方法。方法名相同而表示含义不同，这叫做构造方法的重载。

二十二.垃圾回收

1.引用计数算法

对每一个对象保存一个整型的引用计数器属性，用于记录对象被引用的情况。

优点：实现简单，垃圾对象便于辨识；判定效率高，回收没有延迟性。

缺点：增加了存储空间的开销。增加了时间开销。无法处理循环引用的情况。

2.可达性分析算法(根搜索算法、追踪性垃圾收集)

通过一系列的"GC roots"对象作为起点搜索。可以有效解决在引用计数算法中循环引用的问题，防止内存泄漏的发生。

“GC Roots”根集合就是一组必须活跃的引用

3.通用分代垃圾回收

（1）.三种状态

A.年轻态：所有的新生成的对象都放在Enen区中，年轻代的目标是尽可能快的收集那些生命周期短的对象，对应着Minor GC。

   B.年老代：在年轻态中存在了15次垃圾回收后还存在的对象（生命周期较长）。当年老代的对象越来越多，我们就需要启动Major GC和Full GC（全量回收）全面清理年轻代和年老态对象。

   C.持久态：用于存放静态文件，如Java类，方法等，持久态对象对垃圾回收午显著影响。

 二十三.this的本质

就是一个真实的对象。比如我们都是“人”，而你和我其实就是“人”类的实例了。实例化就是创建对象的过程，使用new关键词类创建。
创建一个对象有如下四步:
1.分配对象空间，并将对象的成员变量初始化为0或空；
2.执行属性值的显示初始化；
3.执行构造方法；
4.返回对象的地址给相关的变量。

this的本质就是“创建好的对象的地址”；由于在构造方法调用前,对象已经创建，因此,在构造方法中也可以使用this代表“当前对象"。

二十四.static关键字

1.（1）.static修饰的变量和方法是属于类的。

（2）.static修饰的变量和对象，方法存储在方法区的静态常量池中；是共享的；

（3）.可以在没有创建任何对象的前提下，仅仅通过类本身来调用static方法

（4）.static修饰的代码块在main方法前执行，目的是修饰main方法

（5）.static关键字修饰的方法或者变量不需要依赖于对象来进行访问，只要类被加载了，就可以通过类名去进行访问

（6）.static方法是没有this的方法，在static方法内部不能调用非静态方法，反过来是可以的

二十五.静态初始化块

1. 上溯到Object类，先执行Object的静态初始化块，再向下执行子类的静态初始化块，直到我们的类的静态初始化块为止。

2. 构造方法执行顺序和上面顺序一样!!

3.静态初始化块，用于类的初始化操作，在静态初始化块中不能直接访问非static成员。

二十六.Java的机制

1.Java 编程语言只有值传递参数。当一个对象实例作为一个参数被传递到方法中时，参数的值就是该对象的引用一个副本。指向同一个对象,对象的内容可以在被调用的方法中改变，但对象的引用(不是引用的副本)是永远不会改变的。Java参数，不管是原始类型还是引用类型，传递的都是副本(有另外一种说法是传值，但是说传副本更好理解吧，传值通常是相对传址而言)。

2.通过package实现对类的管理，package的使用有两个要点：
通常是类的第一句非注释性语句。
包名：域名倒着写，再加上模块名，便于内部管理类。

3.package的命名

com.sun.test
com.oracle.test
com.sxt.wang.test
com.sxt.wang.view
com.sxt.wang.view.model

注意问题：
写项目时都要加包，不要使用默认包
com.wang和com.wang.car，两个包没有包含关系，是两个完全独立的逻辑结构。

二十七.import详解

如果在当前A包中，想使用B包中的类，则可以使用import 关键字进行导入。

格式：import  包名.类名  //  eg:import  java.util.Arrays;

如果想调用该类的方法使用：Arrays.sort();调用

注意：

= 对于java.lang 中的类系统会自动导入。eg: System  /  String

但是对于java.lang包的子包系统不会加载必须写出来。eg:java.lang.reflect.*;//lang 包下的子包中的类

=  如果需要使用一个包中的多个类，可以用  import  java.util.* ;  表示只加载在当前类中使用到的工具类。

二十八.intanceof的使用

1.java 中的instanceof是一个运算符，而且是二目运算符，即有两个操作数。该运算符是用来在运行时指出对象是否是特定类的一个实例。instanceof通过返回一个布尔值来指出，这个对象是否是这个特定类或者是它的子类的一个实例。
 2.用法：
result = object instanceof class
3.参数：
Result：布尔类型。
Object：必选项。任意对象表达式。
Class：必选项。任意已定义的对象类。
说明：
如果 object 是 class 的一个实例，则 instanceof 运算符返回 true。如果 object 不是指定类的一个实例，或者 object 是 null，则返回 false。

public class C extends B {

    private void print(Object a) {
        System.out.println(a+" instanceof");
    }

    public void convert(String b) {

        if (b instanceof Object) {
            this.print(b);
        }
    }

}

二十九.方法的重写

1.重写是子类对父类的允许访问的方法的实现过程进行重新编写！返回值和形参都不能改变。即外壳不变，核心重写。重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。

2.方法重写的规则
（1）.参数列表必须完全与被重写方法的相同；
（2）.返回类型必须完全与被重写方法的返回类型相同；
（3）.访问权限不能比父类中被重写的方法的访问权限更高。例如：如果父类的一个方法被声明为public，那么在子类中重写该方法就不能声明为protected。

三十.object类的toString方法
1、直接打印对象的地址值没有意义，需要重写Object类中的toString方法打印对象的属性。
2、看一个类是否重写了tostring()方法，直接打印这个类的对象即可，如果没有重写toString()方法，那么打印的是对象的地址值。

三十一.equals方法的重写

1.Object类是所有类的父类。换句话说，任何类都隐含地继承了该方法。判断两个对象的内容是否相同，必须使用equals()方法，对于没有重写该方法的类，需要重写该方法

 2.对象内容的比较，需要使用equals()方法，若是对于已经重写该方法的类，例如String类，就无需再重写；若是没有重写，例如自定义的User类，就需要重写。

 3.Java语言中的“==”对于基本数据类型就是比较其值，而对于对象就是比较对象的引用。

三十二.super的用法

1.super能出现在实例方法和构造方法中。

2.super的语法是“super.”和“super()”。

3. super不能出现在静态方法中。

4. super大部分情况下是可以省略的。

5.super和this区别是：this可以看做一个引用变量，保存了该对象的地址，是当前对象整体，而super代表的是父类型特征，是子类局部的一些东西，这些继承过来的东西已经在子类里面了，你可以输出整体this，但不能输出父类型特征super。因为super指向的东西不是一个整体，没法打印输出。

6.this和super都只能在对象内部使用。
this代表当前对象本身，super代表当前对象的父类型特征。

7.总结：“this.”是一个实例对象内部为了区分实例变量和局部变量。
而“super.”是一个实例对象为了区分是子类的成员还是父类的成员。
父类有，子类也有，子类想访问父类的，“super.”不能省略。**

8.super()只能出现在构造方法的第一行，通过当前的构造方法去调用“父类”中的对应的构造方法，目的是：创建子类对象时，先初始化父类型特征

三十三.封装

1.public： 可以被同项目中的所有类访问（所有可访问）
protected:同包中的所有类和不同包的子类可以访问，其他情况不可用（同包和不同包子类可访问）
(default)：同包中的所有类可以访问（同包可访问）
private：只允许在本类中进行访问，其他情况不可用（本类可访问）

2.封装的使用细节：

1）.一般使用private访问权限
2）.为了让其他的类可以使用这些属性提供相应的get和set方法

public class Data {
 
	private int id;
	private String value;
 
	public int getId() {
		return id;
	}
 
	public void setId(int id) {
		this.id = id;
	}
 
	public String getValue() {
		return value;
	}
 
	public void setValue(String value) {
		this.value = value;
	}
 
}

三十四.多态

1.多态的三个必要条件

1）.需要有继承关系的存在

2）.需要有方法的重写

3）.需要有父类的引用指向子类对象

public class TestAnimal {
    public static void main(String[] args) {
        Animal a = new Animal();
        animalCry(a);
 
        Dog d = new Dog();
        animalCry(d);
 
        Cat t = new Cat();
        animalCry(t);
    }
 
    //多态的关键，通过父类的引用调用子类重写的方法。
    static void animalCry(Animal a) {
        a.shout();
    }
}
class Animal{
    public void shout() {
        System.out.println("animal 叫了一声");
    }
}
 
class Dog extends Animal{
    public void shout() {
        System.out.println("dog 汪汪汪！");
    }
}
 
class Cat extends Animal{
    public void shout() {
        System.out.println("cat 喵喵喵！");
    }
}

2.对象的转型

package 对象的上转型对象;

public class Test {
	public static void main(String[] args) {
		Anthropoid monkey;
	    People geng=new People();
	    monkey=geng;//monkey是People对象geng的上转型对象
	    monkey.crySpeck("I love this game");
	    geng.crySpeck("I love this game");
	    People people=(People)monkey;//把上转型对象强制转化为子类的对象 
	    people.computer(10, 10);
	}
}

三十五.数组

1.数组的三种初始化方式

1）.静态初始化：除了用new关键字来产生数组以外，还可以直接在定义数组的同时就为数组元素分配空间并赋值。

动态初始化：数组定义与为数组元素分配空间并赋值的操作分开进行

默认初始化：数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化（即使不给赋初值，也会被程序赋予默认值）。

2.数组的遍历