环境变量：

JDK, JRE,JVM三者之间的关系，以及JDK、JRE包含的主要结构有哪些
JDK = JRE + Java的开发工具(javac.exe, java.exe, javadoc.exe)
JRD=JVM+JAVA核心类库

2.为什么要配置path环境变量?如何配置?
JAVA_ HOME = bin的上一层目录
path = %JAVA_ HOME%\bin

定义变量

由26个英文字母大小写，0-9，_或$组成
包名：多单词组成时所有字母都小写：xxxyyyzzz
类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyzzz
变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxyyzz
常量名：所有字母都大写，多单词时每个单词用下划线连接：xxxw-zzz

变量分类

整型

byte：-128 ~ 127
声明long型变量，必须以"l"或"L"结尾
通常，定义整型变量时，使用int型

浮点

float：单精度，尾数可以精确到7位有效数字。很多情况下，精度很难满足需求
double：双精度，精度是float的两倍。通常采用此类型
Java的浮点型常量默认为double型，声明float型常量，须后加“f”或”F“

字符型char

1字符-2字节
定义char型变量，通常使用一对’ ’ ，内部只能写一个字符
表示方式：1.声明一个字符2.转义字符3.直接使用Unicode值来表示字符型常量

布尔类型

跟其他语言不一样:不能用0表示false或不能用1表示true

类型转换

自动类型提升

java在做运算的时候，如果操作数均在int范围内，那么一律在int的空间内运算。

强制类型

double d1 =12.9;
int il =（int）d1;// 12 截断操作int i2 = 128;
byte b = (byte)i2;System.out.println(b);// -128  精度损失2

特殊情况

String

string可以和8种基本数据类型变量做运算，且运算只能是连接运算：+
运算的结果仍然是string类型

进制

反=补-1
负数:反=符号不变，其他位取反,取反~:符号和其他位都要变,
补码运算
位移<<符号不变，0填充
位移>>符号不变，符号位填充二，八，十六转十->各自的平次次-1
十转二，八，十六->各自的余数
二转八，十六->固定位数转化
八，十六转二->固定位数转化

运算符（忽略）

数组

理论

数组的理解：数组（Array），是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理。
数组是有序排列的
数组属于引用数据类型的变量。
数组的元素，既可以是基本数据类型，也可以是引用数据类型
创建数组对象会在内存中开辟一整块连续的空间
数组的长度一旦确定，就不能修改。

一维数组

/*        // 1初始化数组// 1.1 静态数组int[] ai1 = new int[]{10,20,30};// 1.2 动态数组int[] ai2 = new int[3];ai2[0] = 10;ai2[1] = 20;ai2[2] = 30;
//        ai2[3] = 40; // java.lang.ArrayIndexOutOfBoundsException:*//*        // 3 数组长度System.out.println(ai1.length); // 3*//*        // 4 数组遍历for (int i = 0; i < ai2.length; i++) {System.out.println(ai2[i]);}//10//20//30*//* // 5 数组的初始化*//*总结：数组元素是整型：0数组元素是浮点型：0.0数组元素是char型：0或'\ueooe'，而非'e' (ascll码0对应的就是空格)数组元素是boolean型：false数组元素是引用数据类型：null* *//*int[] a1 = new int[3];for (int i = 0; i < a1.length; i++) {System.out.println(a1[i]);}//0//0//0System.out.println("*********************************");short[] a2 = new short[3];for (int i = 0; i < a2.length; i++) {System.out.println(a2[i]);}//0//0//0System.out.println("*********************************");float[] a3 = new float[3];for (int i = 0; i < a3.length; i++) {System.out.println(a3[i]);}//0.0//0.0//0.0System.out.println("*********************************");char[] a4 = new char[3];for (int i = 0; i < a4.length; i++) {System.out.println(a4[i]);}// 你看到n个空格，是因为：ascll码0对应的就是空格System.out.println("*********************************");boolean[] a5 = new boolean[3];for (int i = 0; i < a5.length; i++) {System.out.println(a5[i]);}// false//false//falseSystem.out.println("*********************************");String[] a6 = new String[3];for (int i = 0; i < a6.length; i++) {System.out.println(a6[i]);}//null//null//null*/

多维数组

        // 一维数组补充-类型推断int[] a1 = new int[]{1,2,3};int[] a2 = {1,2,3}; // 类型推断// 1 二维数组初始化// 1.1 静态初始化int[][] aa1 = new int[][]{{1,2,3},{10,20,30}};// 1.2 动态初始化1int[][] aa2 = new int[3][3];// 1.3 动态初始化2int[][] aa3 = new int[3][];/*        // 2 调用System.out.println(aa2[0][1]); // 0
//        System.out.println(aa3[0][1]); // NullPointerException*//*        // 3 赋值aa3[0] = new int[]{1,24,5};System.out.println(aa3[0][1]); // 24*//*        // 4 遍历for (int i = 0; i < aa1.length; i++) {for (int j = 0; j < aa1[i].length; j++) {System.out.println(aa1[i][j]);}}// 1//2//3//10//20//30*/
/*// 5 数组初始化,地址值-注意看前面是一维还是二维和类型System.out.println(a1); // [I@1b6d3586System.out.println(aa2); // [[I@4554617cSystem.out.println(aa2[0]); // [I@74a14482System.out.println(aa2[0][0]); // 0System.out.println(aa3[0]); // null
*/

面向对象(上)

创建类的对象=类的实例化=实例化类
通过“对象.属性"或“对象.方法"调用对象的结构

内存解析

属性（成员变量） vs 局部变量

我们在调用局部变量之前，一定要显式赋值。
类是地址传递，浅复制

/** 类中属性的使用* * 属性（成员变量）   vs  局部变量* 1.相同点：*         1.1  定义变量的格式：数据类型  变量名 = 变量值*       1.2 先声明，后使用*         1.3 变量都有其对应的作用域 * * * 2.不同点：*        2.1 在类中声明的位置的不同*        属性：直接定义在类的一对{}内*         局部变量：声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量*        *       2.2 关于权限修饰符的不同*         属性：可以在声明属性时，指明其权限，使用权限修饰符。*            常用的权限修饰符：private、public、缺省、protected  --->封装性*            目前，大家声明属性时，都使用缺省就可以了。*        局部变量：不可以使用权限修饰符。* *      2.3 默认初始化值的情况：*      属性：类的属性，根据其类型，都有默认初始化值。*           整型（byte、short、int、long）：0*             浮点型（float、double）：0.0*             字符型（char）：0  （或'\u0000'）*          布尔型（boolean）：false* *          引用数据类型（类、数组、接口）：null* *        局部变量：没有默认初始化值。*          意味着，我们在调用局部变量之前，一定要显式赋值。*             特别地：形参在调用时，我们赋值即可。* *         2.4 在内存中加载的位置：*      属性：加载到堆空间中   （非static）*        局部变量：加载到栈空间* */

JVM

虚拟机栈,即为平时提到的栈结构。我们将局部变量存储在栈结构中
堆，我们将new出来的结构(比如:数组、对象)加载在对空间中。补充:对象的属性(非static的) 加载在堆空间中。
方法区:类的加载信息、常量池、静态域

匿名对象

new xx 时没赋值，一般用于该对象做方法参数

再谈方法-重载

在同一个类中，允许存在一一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。
跟方法的权限修饰符、返回值类型、形参变量名、方法体都没有关系!

可变个数形参的方法

/** 1.jdk 5.0新增的内容* 2.具体使用：*   2.1 可变个数形参的格式：数据类型 ... 变量名*   2.2 当调用可变个数形参的方法时，传入的参数个数可以是：0个，1个,2个，。。。*   2.3 可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载*   2.4 可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间不构成重载。换句话说，二者不能共存。*   2.5 可变个数形参在方法的形参中，必须声明在末尾*   2.6  可变个数形参在方法的形参中,最多只能声明一个可变形参。* */

值传递

赋值

 * *  如果变量是基本数据类型，此时赋值的是变量所保存的数据值。*  如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值。

传参

 * 如果参数是基本数据类型，此时实参赋给形参的是实参真实存储的数据值。* 如果参数是引用数据类型，此时实参赋给形参的是实参存储数据的地址值。

递归

 * 递归方法的使用（了解）* 1.递归方法：一个方法体内调用它自身。* 2. 方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无须循环控制。* 递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环。

封装与隐藏

 * 面向对象的特征一：封装与隐藏* 一、问题的引入：*  当我们创建一个类的对象以后，我们可以通过"对象.属性"的方式，对对象的属性进行赋值。这里，赋值操作要受到*  属性的数据类型和存储范围的制约。除此之外，没有其他制约条件。但是，在实际问题中，我们往往需要给属性赋值*  加入额外的限制条件。这个条件就不能在属性声明时体现，我们只能通过方法进行限制条件的添加。（比如：setLegs()）*  同时，我们需要避免用户再使用"对象.属性"的方式对属性进行赋值。则需要将属性声明为私有的(private).*  -->此时，针对于属性就体现了封装性。* * 二、封装性的体现：* 我们将类的属性xxx私有化(private),同时，提供公共的(public)方法来获取(getXxx)和设置(setXxx)此属性的值* *  拓展：封装性的体现：① 如上  ② 不对外暴露的私有的方法  ③ 单例模式   ...*  * * 三、封装性的体现，需要权限修饰符来配合。* 1.Java规定的4种权限（从小到大排列）：private、缺省、protected 、public * 2.4种权限可以用来修饰类及类的内部结构：属性、方法、构造器、内部类* 3.具体的，4种权限都可以用来修饰类的内部结构：属性、方法、构造器、内部类*        修饰类的话，只能使用：缺省、public

构造器

属性赋值的先后顺序

/** 总结：属性赋值的先后顺序* * * ① 默认初始化* ② 显式初始化* ③ 构造器中初始化* * ④ 通过"对象.方法" 或 "对象.属性"的方式，赋值* * 以上操作的先后顺序：① - ② - ③ - ④  * */

this

/** this关键字的使用：* 1.this可以用来修饰、调用：属性、方法、构造器* * 2.this修饰属性和方法：*   this理解为：当前对象  或 当前正在创建的对象* *  2.1  在类的方法中，我们可以使用"this.属性"或"this.方法"的方式，调用当前对象属性或方法。但是，*   通常情况下，我们都选择省略"this."。特殊情况下，如果方法的形参和类的属性同名时，我们必须显式*   的使用"this.变量"的方式，表明此变量是属性，而非形参。* *  2.2 在类的构造器中，我们可以使用"this.属性"或"this.方法"的方式，调用当前正在创建的对象属性或方法。*  但是，通常情况下，我们都选择省略"this."。特殊情况下，如果构造器的形参和类的属性同名时，我们必须显式*   的使用"this.变量"的方式，表明此变量是属性，而非形参。* * 3. this调用构造器*    ① 我们在类的构造器中，可以显式的使用"this(形参列表)"方式，调用本类中指定的其他构造器*    ② 构造器中不能通过"this(形参列表)"方式调用自己*    ③ 如果一个类中有n个构造器，则最多有 n - 1构造器中使用了"this(形参列表)"*    ④ 规定："this(形参列表)"必须声明在当前构造器的首行*    ⑤ 构造器内部，最多只能声明一个"this(形参列表)"，用来调用其他的构造器* * */

package和important

package

为了更好的实现项目中类的管理，提供包的概念
使用package声明类或接口所属的包，声明在源文件的首行
同一个包下，不能命名同名的接口、类。
不同的包下，可以命名同名的接口、类。

important

 * import:导入* 1. 在源文件中显式的使用import结构导入指定包下的类、接口* 2. 声明在包的声明和类的声明之间* 3. 如果需要导入多个结构，则并列写出即可* 4. 可以使用"xxx.*"的方式，表示可以导入xxx包下的所有结构* 5. 如果使用的类或接口是java.lang包下定义的，则可以省略import结构* 6. 如果使用的类或接口是本包下定义的，则可以省略import结构* 7. 如果在源文件中，使用了不同包下的同名的类，则必须至少有一个类需要以全类名的方式显示。* 8. 使用"xxx.*"方式表明可以调用xxx包下的所有结构。但是如果使用的是xxx子包下的结构，则仍需要显式导入* * 9. import static:导入指定类或接口中的静态结构:属性或方法。

面向对象(中)

继承性

DEBUG

重写

/** 方法的重写(override / overwrite)* * 1.重写：子类继承父类以后，可以对父类中同名同参数的方法，进行覆盖操作* * 2.应用：重写以后，当创建子类对象以后，通过子类对象调用子父类中的同名同参数的方法时，实际执行的是子类重写父类的方法。* * 3. 重写的规定：*          方法的声明： 权限修饰符  返回值类型  方法名(形参列表) throws 异常的类型{*                        //方法体*                  }*          约定俗称：子类中的叫重写的方法，父类中的叫被重写的方法*      ① 子类重写的方法的方法名和形参列表与父类被重写的方法的方法名和形参列表相同*      ② 子类重写的方法的权限修饰符不小于父类被重写的方法的权限修饰符*          >特殊情况：子类不能重写父类中声明为private权限的方法*      ③ 返回值类型：*         >父类被重写的方法的返回值类型是void，则子类重写的方法的返回值类型只能是void*       >父类被重写的方法的返回值类型是A类型，则子类重写的方法的返回值类型可以是A类或A类的子类*        >父类被重写的方法的返回值类型是基本数据类型(比如：double)，则子类重写的方法的返回值类型必须是相同的基本数据类型(必须也是double)*      ④ 子类重写的方法抛出的异常类型不大于父类被重写的方法抛出的异常类型（具体放到异常处理时候讲）*  ***********************************************************************     子类和父类中的同名同参数的方法要么都声明为非static的（考虑重写），要么都声明为static的（不是重写）。 ** 面试题：区分方法的重载与重写*/

权限修饰符

//不同包下的普通类（非子类）要使用Order类，不可以调用声明为private、缺省、protected权限的属性、方法
//在不同包的子类中，不能调用Order类中声明为private和缺省权限的属性、方法

super

/** super关键字的使用* 1.super理解为：父类的* 2.super可以用来调用：属性、方法、构造器* * 3.super的使用：调用属性和方法* *   3.1 我们可以在子类的方法或构造器中。通过使用"super.属性"或"super.方法"的方式，显式的调用*   父类中声明的属性或方法。但是，通常情况下，我们习惯省略"super."*   3.2 特殊情况：当子类和父类中定义了同名的属性时，我们要想在子类中调用父类中声明的属性，则必须显式的*   使用"super.属性"的方式，表明调用的是父类中声明的属性。*   3.3 特殊情况：当子类重写了父类中的方法以后，我们想在子类的方法中调用父类中被重写的方法时，则必须显式的*   使用"super.方法"的方式，表明调用的是父类中被重写的方法。* * 4.super调用构造器*     4.1  我们可以在子类的构造器中显式的使用"super(形参列表)"的方式，调用父类中声明的指定的构造器*   4.2 "super(形参列表)"的使用，必须声明在子类构造器的首行！*   4.3 我们在类的构造器中，针对于"this(形参列表)"或"super(形参列表)"只能二选一，不能同时出现*   4.4 在构造器的首行，没有显式的声明"this(形参列表)"或"super(形参列表)"，则默认调用的是父类中空参的构造器：super()*   4.5 在类的多个构造器中，至少有一个类的构造器中使用了"super(形参列表)"，调用父类中的构造器*/

多态

/** 面向对象特征之三：多态性* * 1.理解多态性：可以理解为一个事物的多种形态。* 2.何为多态性：*   对象的多态性：父类的引用指向子类的对象（或子类的对象赋给父类的引用）*   * 3. 多态的使用：虚拟方法调用*   有了对象的多态性以后，我们在编译期，只能调用父类中声明的方法，但在运行期，我们实际执行的是子类重写父类的方法。*   总结：编译，看左边；运行，看右边。*   * 4.多态性的使用前提：  ① 类的继承关系  ② 方法的重写* * 5.对象的多态性，只适用于方法，不适用于属性（编译和运行都看左边）*/

     System.out.println("*******************");//对象的多态性：父类的引用指向子类的对象Person p2 = new Man();
//      Person p3 = new Woman();//多态的使用：当调用子父类同名同参数的方法时，实际执行的是子类重写父类的方法 ---虚拟方法调用p2.eat();p2.walk();//       p2.earnMoney();

多态举例

//多态性的使用举例一：
public class AnimalTest {public static void main(String[] args) {AnimalTest test = new AnimalTest();test.func(new Dog());test.func(new Cat());}public void func(Animal animal){//Animal animal = new Dog();animal.eat();animal.shout();if(animal instanceof Dog){Dog d = (Dog)animal;d.watchDoor();}}//  public void func(Dog dog){//      dog.eat();
//      dog.shout();
//  }
//  public void func(Cat cat){//      cat.eat();
//      cat.shout();
//  }
}class Animal{public void eat(){System.out.println("动物：进食");}public void shout(){System.out.println("动物：叫");}}class Dog extends Animal{public void eat(){System.out.println("狗吃骨头");}public void shout(){System.out.println("汪！汪！汪！");}public void watchDoor(){System.out.println("看门");}
}
class Cat extends Animal{public void eat(){System.out.println("猫吃鱼");}public void shout(){System.out.println("喵！喵！喵！");}
}

虚拟方法

向下转型的使用

多态是左高低
向下转是，必须比右高，比左低？

     //不能调用子类所特有的方法、属性：编译时，p2是Person类型。p2.name = "Tom";
//      p2.earnMoney();
//      p2.isSmoking = true;//有了对象的多态性以后，内存中实际上是加载了子类特有的属性和方法的，但是由于变量声明为父类类型，导致//编译时，只能调用父类中声明的属性和方法。子类特有的属性和方法不能调用。//如何才能调用子类特有的属性和方法？//向下转型：使用强制类型转换符。Man m1 = (Man)p2;m1.earnMoney();m1.isSmoking = true;

instanceof关键字的使用

实列化时，等式左右都 instanceof返回tru,至少比右边高？
父子类才返回true

     //使用强转时，可能出现ClassCastException的异常。
//      Woman w1 = (Woman)p2;
//      w1.goShopping();/** instanceof关键字的使用* * a instanceof A:判断对象a是否是类A的实例。如果是，返回true；如果不是，返回false。* * *  使用情境：为了避免在向下转型时出现ClassCastException的异常，我们在向下转型之前，先*  进行instanceof的判断，一旦返回true，就进行向下转型。如果返回false，不进行向下转型。*  *  如果 a instanceof A返回true,则 a instanceof B也返回true.*  其中，类B是类A的父类。*/if(p2 instanceof Woman){Woman w1 = (Woman)p2;w1.goShopping();System.out.println("******Woman******");}if(p2 instanceof Man){Man m2 = (Man)p2;m2.earnMoney();System.out.println("******Man******");}if(p2 instanceof Person){System.out.println("******Person******");}if(p2 instanceof Object){System.out.println("******Object******");}

多态调用子类的属性

对象的多态性，只适用于方法，不适用于属性（编译和运行都看左边）
多态后，可以通过调用同类的子类方法来调用子类的属性

class Base {int count = 10;public void display() {System.out.println(this.count);}
}class Sub extends Base {int count = 20;public void display() {System.out.println(this.count);}
}public class FieldMethodTest {public static void main(String[] args) {Sub s = new Sub();System.out.println(s.count);//20s.display();//20Base b = s;//多态性//==：对于引用数据类型来讲，比较的是两个引用数据类型变量的地址值是否相同System.out.println(b == s);//trueSystem.out.println(b.count);//10b.display();//20}
}

Object类的使用

 * java.lang.Object类* 1.Object类是所有Java类的根父类* 2.如果在类的声明中未使用extends关键字指明其父类，则默认父类为java.lang.Object类 * 3.Object类中的功能(属性、方法)就具有通用性。*  属性：无*  方法：equals() / toString() / getClass() /hashCode() / clone() / finalize()*     wait() 、 notify()、notifyAll()* * 4. Object类只声明了一个空参的构造器

equals和==

/** * 面试题： == 和 equals() 区别* * 一、回顾 == 的使用：* == ：运算符* 1. 可以使用在基本数据类型变量和引用数据类型变量中* 2. 如果比较的是基本数据类型变量：比较两个变量保存的数据是否相等。（不一定类型要相同）*    如果比较的是引用数据类型变量：比较两个对象的地址值是否相同.即两个引用是否指向同一个对象实体* 补充： == 符号使用时，必须保证符号左右两边的基本变量类型一致。(比如int==double返回true，但int==boolean编译错误)* * 二、equals()方法的使用：* 1. 是一个方法，而非运算符* 2. 只能适用于引用数据类型* 3. Object类中equals()的定义：*    public boolean equals(Object obj) {return (this == obj);}*    说明：Object类中定义的equals()和==的作用是相同的：比较两个对象的地址值是否相同.即两个引用是否指向同一个对象实体* * 4. 像String、Date、File、包装类等都重写了Object类中的equals()方法。重写以后，比较的不是*    两个引用的地址是否相同，而是比较两个对象的"实体内容"是否相同。*    * 5. 通常情况下，我们自定义的类如果使用equals()的话，也通常是比较两个对象的"实体内容"是否相同。那么，我们*    就需要对Object类中的equals()进行重写.*    重写的原则：比较两个对象的实体内容是否相同.*/

toString

   1. 当我们输出一个对象的引用时，实际上就是调用当前对象的toString()* * 2. Object类中toString()的定义：*   public String toString() {return getClass().getName() + "@" + Integer.toHexString(hashCode());}* * 3. 像String、Date、File、包装类等都重写了Object类中的toString()方法。*    使得在调用对象的toString()时，返回"实体内容"信息*    * 4. 自定义类也可以重写toString()方法，当调用此方法时，返回对象的"实体内容"

JUnit单元测试

 * 2.创建Java类，进行单元测试。*   此时的Java类要求：① 此类是public的  ②此类提供公共的无参的构造器* 3.此类中声明单元测试方法。*   此时的单元测试方法：方法的权限是public,没返回值，没形参* * 4.此单元测试方法上需要声明注解：@Test,并在单元测试类中导入：import org.junit.Test;

包装类的使用

基本数据类型<--->包装类：JDK 5.0 新特性：自动装箱 与自动拆箱
基本数据类型、包装类--->String:调用String重载的valueOf(Xxx xxx)
String--->基本数据类型、包装类:调用包装类的parseXxx(String s)注意：转换时，可能会报NumberFormatException

面向对象(下)

static

/** static关键字的使用* * 1.static:静态的* 2.static可以用来修饰：属性、方法、代码块、内部类* * 3.使用static修饰属性：静态变量（或类变量）*         3.1 属性，按是否使用static修饰，又分为：静态属性  vs 非静态属性(实例变量)*            实例变量：我们创建了类的多个对象，每个对象都独立的拥有一套类中的非静态属性。当修改其中一个对象中的*              非静态属性时，不会导致其他对象中同样的属性值的修改。*       静态变量：我们创建了类的多个对象，多个对象共享同一个静态变量。当通过某一个对象修改静态变量时，会导致*              其他对象调用此静态变量时，是修改过了的。*        3.2 static修饰属性的其他说明：*            ① 静态变量随着类的加载而加载。可以通过"类.静态变量"的方式进行调用*          ② 静态变量的加载要早于对象的创建。*          ③ 由于类只会加载一次，则静态变量在内存中也只会存在一份：存在方法区的静态域中。*          *          ④      类变量 实例变量*          类        yes     no*          对象     yes     yes*          *      3.3 静态属性举例：System.out; Math.PI;* * 4.使用static修饰方法：静态方法*      ① 随着类的加载而加载，可以通过"类.静态方法"的方式进行调用*       ②           静态方法    非静态方法*          类       yes     no*          对象     yes     yes*        ③ 静态方法中，只能调用静态的方法或属性*        非静态方法中，既可以调用非静态的方法或属性，也可以调用静态的方法或属性* * 5. static注意点：*    5.1 在静态的方法内，不能使用this关键字、super关键字*    5.2 默认可以不写，写的话是类名.xx*    * 6. 开发中，如何确定一个属性是否要声明为static的？*        > 属性是可以被多个对象所共享的，不会随着对象的不同而不同的。*      > 类中的常量也常常声明为static* *    开发中，如何确定一个方法是否要声明为static的？*      > 操作静态属性的方法，通常设置为static的*      > 工具类中的方法，习惯上声明为static的。 比如：Math、Arrays、Collections*/

设计模式-单例

饿汉式

public class SingletonTest1 {public static void main(String[] args) {//      Bank bank1 = new Bank();
//      Bank bank2 = new Bank();Bank bank1 = Bank.getInstance();Bank bank2 = Bank.getInstance();System.out.println(bank1 == bank2); // true}
}class Bank{//1.私有化类的构造器private Bank(){}//2.内部创建类的对象//4.要求此对象也必须声明为静态的private static Bank instance = new Bank(); //饿汉式//3.提供公共的静态的方法，返回类的对象public static Bank getInstance(){return instance;}
}

懒汉式

public class SingletonTest2 {public static void main(String[] args) {Order order1 = Order.getInstance();Order order2 = Order.getInstance();System.out.println(order1 == order2);}
}class Order{//1.私有化类的构造器private Order(){}//2.声明当前类对象，没有初始化//4.此对象也必须声明为static的private static Order instance = null; // 懒汉式//3.声明public、static的返回当前类对象的方法public static Order getInstance(){if(instance == null){instance = new Order();}return instance;}}

饿汉式和懒汉式的区别

 * 3. 区分饿汉式 和 懒汉式*   饿汉式： *       坏处：对象加载时间过长。*    好处：饿汉式是线程安全的*   *   懒汉式：好处：延迟对象的创建。*         目前的写法坏处：线程不安全。--->到多线程内容时，再修改

单例模式的优点:

由于单例模式只生成一个实例，减少了系统性能开销，当一个对象的
产生需要比较多的资源时，如读取配置、产生其他依赖对象时，则可
以通过在应用启动时直接产生一一个单例对象，然后永久驻留内存的方
式来解决。

main

 * main()方法的使用说明：* 1. main()方法作为程序的入口* 2. main()方法也是一个普通的静态方法(静态只能调用静态的方法或属性)* 3. main()方法可以作为我们与控制台交互的方式。（之前：使用Scanner）

代码块

/** 类的成员之四：代码块（或初始化块）* * 1. 代码块的作用：用来初始化类、对象* 2. 代码块如果有修饰的话，只能使用static.* 3. 分类：静态代码块  vs 非静态代码块* * 4. 静态代码块*      >内部可以有输出语句*      >随着类的加载而执行,而且只执行一次*      >作用：初始化类的信息*      >如果一个类中定义了多个静态代码块，则按照声明的先后顺序执行*       >静态代码块的执行要优先于非静态代码块的执行*      >静态代码块内只能调用静态的属性、静态的方法，不能调用非静态的结构* * 5. 非静态代码块*        >内部可以有输出语句*      >随着对象的创建而执行*         >每创建一个对象，就执行一次非静态代码块*         >作用：可以在创建对象时，对对象的属性等进行初始化*         >如果一个类中定义了多个非静态代码块，则按照声明的先后顺序执行*      >非静态代码块内可以调用静态的属性、静态的方法，或非静态的属性、非静态的方法* */

由父及子，静态先行，静态代码块>普通代码块>构造器

package com.atguigu.java3;
//总结：由父及子，静态先行
class Root{static{System.out.println("Root的静态初始化块");}{System.out.println("Root的普通初始化块");}public Root(){super();System.out.println("Root的无参数的构造器");}
}
class Mid extends Root{static{System.out.println("Mid的静态初始化块");}{System.out.println("Mid的普通初始化块");}public Mid(){super();System.out.println("Mid的无参数的构造器");}public Mid(String msg){//通过this调用同一类中重载的构造器this();System.out.println("Mid的带参数构造器，其参数值："+ msg);}
}
class Leaf extends Mid{static{System.out.println("Leaf的静态初始化块");}{System.out.println("Leaf的普通初始化块");}   public Leaf(){//通过super调用父类中有一个字符串参数的构造器super("尚硅谷");System.out.println("Leaf的构造器");}
}
public class LeafTest{public static void main(String[] args){new Leaf(); System.out.println();new Leaf();}
}

final

/** final:最终的* * 1. final可以用来修饰的结构：类、方法、变量* * 2. final 用来修饰一个类:此类不能被其他类所继承。*          比如：String类、System类、StringBuffer类* * 3. final 用来修饰方法：表明此方法不可以被重写*          比如：Object类中getClass();* * 4. final 用来修饰变量：此时的"变量"就称为是一个常量*      4.1 final修饰属性：可以考虑赋值的位置有：显式初始化、代码块中初始化、构造器中初始化*       4.2 final修饰局部变量：*           尤其是使用final修饰形参时，表明此形参是一个常量。当我们调用此方法时，给常量形参赋一个实参。一旦赋值*           以后，就只能在方法体内使用此形参，但不能进行重新赋值。*           *  static final 用来修饰属性：全局常量*/

属性复赋值顺序

抽象类与抽象方法

/** abstract关键字的使用* 1.abstract:抽象的* 2.abstract可以用来修饰的结构：类、方法* * 3. abstract修饰类：抽象类*        > 此类不能实例化*      > 抽象类中一定有构造器，便于子类实例化时调用（涉及：子类对象实例化的全过程）*      > 开发中，都会提供抽象类的子类，让子类对象实例化，完成相关的操作* * * 4. abstract修饰方法：抽象方法*         > 抽象方法只有方法的声明，没有方法体*      > 包含抽象方法的类，一定是一个抽象类。反之，抽象类中可以没有抽象方法的。*      > 若子类重写了父类中的所有的抽象方法后，此子类方可实例化*        若子类没有重写父类中的所有的抽象方法，则此子类也是一个抽象类，需要使用abstract修饰* * abstract使用上的注意点：* 1.abstract不能用来修饰：属性、构造器等结构* * 2.abstract不能用来修饰私有方法、静态方法、final的方法、final的类* */

abstract-匿名对象和创建抽象类的匿名子类对象

/** 抽象类的匿名子类* Person是抽象类* */
public class PersonTest {public static void main(String[] args) {Worker worker = new Worker();method1(worker);//非匿名的类非匿名的对象method(new Student());//匿名对象method1(new Worker());//非匿名的类匿名的对象System.out.println("********************");//创建了一匿名子类的对象：pPerson p = new Person(){@Overridepublic void eat() {System.out.println("吃东西");}@Overridepublic void breath() {System.out.println("好好呼吸");}};method1(p);System.out.println("********************");//创建匿名子类的匿名对象method1(new Person(){@Overridepublic void eat() {System.out.println("吃好吃东西");}@Overridepublic void breath() {System.out.println("好好呼吸新鲜空气");}});}public static void method1(Person p){p.eat();p.breath();}public static void method(Student s){}
}class Worker extends Person{@Overridepublic void eat() {}@Overridepublic void breath() {}}

模板方法设计模式

/** 抽象类的应用：模板方法的设计模式* */
public class TemplateTest {public static void main(String[] args) {SubTemplate t = new SubTemplate();t.spendTime();}
}abstract class Template{//计算某段代码执行所需要花费的时间public void spendTime(){long start = System.currentTimeMillis();this.code();//不确定的部分、易变的部分long end = System.currentTimeMillis();System.out.println("花费的时间为：" + (end - start));}public abstract void code();}class SubTemplate extends Template{@Overridepublic void code() {for(int i = 2;i <= 1000;i++){boolean isFlag = true;for(int j = 2;j <= Math.sqrt(i);j++){if(i % j == 0){isFlag = false;break;}}if(isFlag){System.out.println(i);}}}}

接口

定义

 * 5. Java开发中，接口通过让类去实现(implements)的方式来使用.*    如果实现类覆盖了接口中的所有抽象方法，则此实现类就可以实例化*    如果实现类没有覆盖接口中所有的抽象方法，则此实现类仍为一个抽象类*    * 6. Java类可以实现多个接口   --->弥补了Java单继承性的局限性*   格式：class AA extends BB implements CC,DD,EE*   * 7. 接口与接口之间可以继承，而且可以多继承* * ******************************** 8. 接口的具体使用，体现多态性* 9. 接口，实际上可以看做是一种规范

接口的使用

/** 接口的使用* 1.接口使用上也满足多态性* 2.接口，实际上就是定义了一种规范* 3.开发中，体会面向接口编程！* */
public class USBTest {public static void main(String[] args) {Computer com = new Computer();//1.创建了接口的非匿名实现类的非匿名对象Flash flash = new Flash();com.transferData(flash);//2. 创建了接口的非匿名实现类的匿名对象com.transferData(new Printer());//3. 创建了接口的匿名实现类的非匿名对象USB phone = new USB(){@Overridepublic void start() {System.out.println("手机开始工作");}@Overridepublic void stop() {System.out.println("手机结束工作");}};com.transferData(phone);//4. 创建了接口的匿名实现类的匿名对象com.transferData(new USB(){@Overridepublic void start() {System.out.println("mp3开始工作");}@Overridepublic void stop() {System.out.println("mp3结束工作");}});}
}class Computer{public void transferData(USB usb){//USB usb = new Flash();usb.start();System.out.println("具体传输数据的细节");usb.stop();}}interface USB{//常量：定义了长、宽、最大最小的传输速度等void start();void stop();}class Flash implements USB{@Overridepublic void start() {System.out.println("U盘开启工作");}@Overridepublic void stop() {System.out.println("U盘结束工作");}}class Printer implements USB{@Overridepublic void start() {System.out.println("打印机开启工作");}@Overridepublic void stop() {System.out.println("打印机结束工作");}}

代理模式

不能看见真实角色

public class StaticProxyTest {public static void main(String[] args) {Proxy s = new Proxy(new RealStar());s.confer();s.signContract();s.bookTicket();s.sing();s.collectMoney();}
}interface Star {void confer();// 面谈void signContract();// 签合同void bookTicket();// 订票void sing();// 唱歌void collectMoney();// 收钱
}
//被代理类
class RealStar implements Star {public void confer() {}public void signContract() {}public void bookTicket() {}public void sing() {System.out.println("明星：歌唱~~~");}public void collectMoney() {}
}//代理类
class Proxy implements Star {private Star real;public Proxy(Star real) {this.real = real;}public void confer() {System.out.println("经纪人面谈");}public void signContract() {System.out.println("经纪人签合同");}public void bookTicket() {System.out.println("经纪人订票");}public void sing() {real.sing();}public void collectMoney() {System.out.println("经纪人收钱");}
}

工厂模式(忽略先)

练习

/** * JDK8：除了定义全局常量和抽象方法之外，还可以定义静态方法、默认方法* */
public interface CompareA {//静态方法public static void method1(){System.out.println("CompareA:北京");}//默认方法public default void method2(){System.out.println("CompareA：上海");}default void method3(){System.out.println("CompareA：上海");}
}

public class SubClassTest {public static void main(String[] args) {SubClass s = new SubClass();//知识点1：接口中定义的静态方法，只能通过接口来调用。
//      s.method1();
//      SubClass.method1();CompareA.method1();//知识点2：通过实现类的对象，可以调用接口中的默认方法。//如果实现类重写了接口中的默认方法，调用时，仍然调用的是重写以后的方法s.method2();//知识点3：如果子类(或实现类)继承的父类和实现的接口中声明了同名同参数的默认方法，//那么子类在没有重写此方法的情况下，默认调用的是父类中的同名同参数的方法。-->类优先原则//知识点4：如果实现类实现了多个接口，而这多个接口中定义了同名同参数的默认方法，//那么在实现类没有重写此方法的情况下，报错。-->接口冲突。//这就需要我们必须在实现类中重写此方法s.method3();}}class SubClass extends SuperClass implements CompareA,CompareB{public void method2(){System.out.println("SubClass：上海");}public void method3(){System.out.println("SubClass：深圳");}//知识点5：如何在子类(或实现类)的方法中调用父类、接口中被重写的方法public void myMethod(){method3();//调用自己定义的重写的方法super.method3();//调用的是父类中声明的//调用接口中的默认方法CompareA.super.method3();CompareB.super.method3();}
}

内部类

/** 类的内部成员之五：内部类* 1. Java中允许将一个类A声明在另一个类B中，则类A就是内部类，类B称为外部类* * 2.内部类的分类：成员内部类（静态、非静态）  vs 局部内部类(方法内、代码块内、构造器内)* * 3.成员内部类：*         一方面，作为外部类的成员：*            >调用外部类的结构*           >可以被static修饰*            >可以被4种不同的权限修饰* *         另一方面，作为一个类：*          > 类内可以定义属性、方法、构造器等*          > 可以被final修饰，表示此类不能被继承。言外之意，不使用final，就可以被继承*            > 可以被abstract修饰* * * 4.关注如下的3个问题*   4.1 如何实例化成员内部类的对象*       //创建Dog实例(静态的成员内部类):Person.Dog dog = new Person.Dog();dog.show();//创建Bird实例(非静态的成员内部类):
//      Person.Bird bird = new Person.Bird();//错误的Person p = new Person();Person.Bird bird = p.new Bird();bird.sing();*   4.2 如何在成员内部类中区分调用外部类的结构* *   4.3 开发中局部内部类的使用  见《InnerClassTest1.java》* */

成员内部类

局部内部类

 //返回一个实现了Comparable接口的类的对象public Comparable getComparable(){//创建一个实现了Comparable接口的类:局部内部类//方式一：
//      class MyComparable implements Comparable{//
//          @Override
//          public int compareTo(Object o) {//              return 0;
//          }
//
//      }
//
//      return new MyComparable();//方式二：匿名局部内部类return new Comparable(){@Overridepublic int compareTo(Object o) {return 0;}};}

异常

常见异常

/** 一、异常体系结构* * java.lang.Throwable*         |-----java.lang.Error:一般不编写针对性的代码进行处理。*         |-----java.lang.Exception:可以进行异常的处理*            |------编译时异常(checked)*                  |-----IOException*                      |-----FileNotFoundException*                    |-----ClassNotFoundException*           |------运行时异常(unchecked,RuntimeException)*                   |-----NullPointerException*                     |-----ArrayIndexOutOfBoundsException*                   |-----ClassCastException*                   |-----NumberFormatException*                    |-----InputMismatchException*                   |-----ArithmeticException* * * * 面试题：常见的异常都有哪些？举例说明*/
public class ExceptionTest {//******************以下是编译时异常***************************@Testpublic void test7(){//      File file = new File("hello.txt");
//      FileInputStream fis = new FileInputStream(file);
//
//      int data = fis.read();
//      while(data != -1){//          System.out.print((char)data);
//          data = fis.read();
//      }
//
//      fis.close();}//******************以下是运行时异常***************************//ArithmeticException@Testpublic void test6(){int a = 10;int b = 0;System.out.println(a / b);}//InputMismatchException@Testpublic void test5(){Scanner scanner = new Scanner(System.in);int score = scanner.nextInt();System.out.println(score);scanner.close();}//NumberFormatException@Testpublic void test4(){String str = "123";str = "abc";int num = Integer.parseInt(str);}//ClassCastException@Testpublic void test3(){Object obj = new Date();String str = (String)obj;}//IndexOutOfBoundsException@Testpublic void test2(){//ArrayIndexOutOfBoundsException
//      int[] arr = new int[10];
//      System.out.println(arr[10]);//StringIndexOutOfBoundsExceptionString str = "abc";System.out.println(str.charAt(3));}//NullPointerException@Testpublic void test1(){//        int[] arr = null;
//      System.out.println(arr[3]);String str = "abc";str = null;System.out.println(str.charAt(0));}}

try…catch

/** 一、异常的处理：抓抛模型* * 过程一："抛"：程序在正常执行的过程中，一旦出现异常，就会在异常代码处生成一个对应异常类的对象。*           并将此对象抛出。*           一旦抛出对象以后，其后的代码就不再执行。*        *       关于异常对象的产生：① 系统自动生成的异常对象*                      ② 手动的生成一个异常对象，并抛出（throw）* * 过程二："抓"：可以理解为异常的处理方式：① try-catch-finally  ② throws* * * 二、try-catch-finally的使用* * try{*        //可能出现异常的代码* * }catch(异常类型1 变量名1){*         //处理异常的方式1* }catch(异常类型2 变量名2){*        //处理异常的方式2* }catch(异常类型3 变量名3){*        //处理异常的方式3* }* ....* finally{*      //一定会执行的代码* }* * 说明：* 1. finally是可选的。* 2. 使用try将可能出现异常代码包装起来，在执行过程中，一旦出现异常，就会生成一个对应异常类的对象，根据此对象*    的类型，去catch中进行匹配* 3. 一旦try中的异常对象匹配到某一个catch时，就进入catch中进行异常的处理。一旦处理完成，就跳出当前的*    try-catch结构（在没有写finally的情况）。继续执行其后的代码* 4. catch中的异常类型如果没有子父类关系，则谁声明在上，谁声明在下无所谓。*    catch中的异常类型如果满足子父类关系，则要求子类一定声明在父类的上面。否则，报错* 5. 常用的异常对象处理的方式： ① String  getMessage()    ② printStackTrace()* 6. 在try结构中声明的变量，再出了try结构以后，就不能再被调用（可在ry前定义好先）* 7. try-catch-finally结构可以嵌套* * 体会1：使用try-catch-finally处理编译时异常，是得程序在编译时就不再报错，但是运行时仍可能报错。*     相当于我们使用try-catch-finally将一个编译时可能出现的异常，延迟到运行时出现。*     * 体会2：开发中，由于运行时异常比较常见，所以我们通常就不针对运行时异常编写try-catch-finally了。*      针对于编译时异常，我们说一定要考虑异常的处理。*/

finally

/** try-catch-finally中finally的使用：* * * 1.finally是可选的* * 2.finally中声明的是一定会被执行的代码。即使catch中又出现异常了，try中有return语句，catch中有* return语句等情况。* * 3.像数据库连接、输入输出流、网络编程Socket等资源，JVM是不能自动的回收的，我们需要自己手动的进行资源的*   释放。此时的资源释放，就需要声明在finally中。* * * */

throws

/** 异常处理的方式二：throws + 异常类型* * 1. "throws + 异常类型"写在方法的声明处。指明此方法执行时，可能会抛出的异常类型。*     一旦当方法体执行时，出现异常，仍会在异常代码处生成一个异常类的对象，此对象满足throws后异常*     类型时，就会被抛出。异常代码后续的代码，就不再执行！*     * 2. 体会：try-catch-finally:真正的将异常给处理掉了。*        throws的方式只是将异常抛给了方法的调用者。  并没有真正将异常处理掉。  * * 3. 开发中如何选择使用try-catch-finally 还是使用throws？*   3.1 如果父类中被重写的方法没有throws方式处理异常，则子类重写的方法也不能使用throws，意味着如果*       子类重写的方法中有异常，必须使用try-catch-finally方式处理。*   3.2 执行的方法a中，先后又调用了另外的几个方法，这几个方法是递进关系执行的。我们建议这几个方法使用throws*       的方式进行处理。而执行的方法a可以考虑使用try-catch-finally方式进行处理。* */
/** 方法重写的规则之一：* 子类重写的方法抛出的异常类型不大于父类被重写的方法抛出的异常类型* * */

thorw-手动抛出异常

Exception ：受检查的异常，这种异常是强制我们catch或throw的异常。你遇到这种异常必须进行catch或throw，如果不处理，编译器会报错。比如：IOException。RuntimeException：运行时异常，这种异常我们不需要处理，完全由虚拟机接管。比如我们常见的NullPointerException，我们在写程序时不会进行catch或throw。RuntimeException也是继承自Exception的，只是虚拟机对这两种异常进行了区分

/** 如何自定义异常类？* 1. 继承于现有的异常结构：RuntimeException 、Exception* 2. 提供全局常量：serialVersionUID* 3. 提供重载的构造器* */
public class MyException extends Exception{static final long serialVersionUID = -7034897193246939L;public MyException(){}public MyException(String msg){super(msg);}
}

JAVA30天-基础篇相关推荐

Python Qt GUI设计：信号与槽的使用方法（基础篇—7）
目录 1.信号与槽的概念 2.信号与槽的基础函数 2.1.创建信号函数 2.2.连接信号函数 2.3.断开信号函数 2.4.发射信号函数 3.信号和槽的使用方法 3.1.内置信号与槽的使用 3.2.自 ...
Python Qt GUI设计：窗口布局管理方法【强化】（基础篇—6）
目录 1. 水平布局类(QHBoxLayout) 2.垂直布局类(QVBoxLayout) 3.网格布局类(QGridLayout) 3.1.单一的网络布局 3.2.跨越行.列的网络布局 4.表单布局 ...
Python Qt GUI设计：窗口布局管理方法【基础】（基础篇—5）
目录 1.布局管理器进行布局 2.容器控件进行布局 3.geometry属性:控件绝对布局 4.sizePolicy属性:微调优化控件布局 Qt Designer提供4种窗口布局方式,分别如下: Ve ...
ES6 你可能不知道的事 – 基础篇
ES6 你可能不知道的事 – 基础篇转载作者:淘宝前端团队(FED)- 化辰链接:taobaofed.org/blog/2016/07/22/es6-basics/ 序 ES6,或许应该叫 ES ...
python多线程并发_Python进阶记录之基础篇（二十四）
回顾在Python进阶记录之基础篇(二十三)中,我们介绍了进程的基本概念以及Python中多进程的基本使用方法.其中,需要重点掌握多进程的创建方法.进程池和进程间的通信.今天我们讲一下Python中 ...
基础篇9-python基本数据结构-列表
基础篇9-python基本数据结构-列表一.列表: 1.有序的集合 2.通过偏移来索引,从而读取数据 3.支持内嵌 a =[[1,2,3],[4,5,6]] 4.可变类型 a[0][1] = 7 二 ...
Linq初级班 Linq To XML体验(基础篇)
LINQ To XML体验(基础) 这两天开始学习LINQ to XML的知识,我会继续把自己的感想和示例发布给初学者们学习的,一样欢迎高手们多多指点,请勿使用过激语言,针锋相对,我是个初学者,自知还 ...
php 爬虫_Scrapy 爬虫完整案例-基础篇
1 Scrapy 爬虫完整案例-基础篇 1.1 Scrapy 爬虫案例一 Scrapy 爬虫案例:爬取腾讯网招聘信息案例步骤: 第一步:创建项目. 在 dos下切换到目录 D:爬虫_scriptsc ...
class括号里的object_Python入门类class 基础篇
记住一句话:类是模板,而实例则是根据类创建的对象. 我初学时对类的理解是从类的字面上,可以片面的认为它是一个种类,它是相似特征的抽像,也就是相似的东西,可以把相似特征的事务抽象成一个类.(事务可以是具 ...