个人零碎笔记

***1 负数二进制表现形式：
6=0110
-6:其实就是6的二进制取反+1， -6=1010
规律：负数的最高位都是1。

***2 3<<4 --> 3*2^4
<<:其实就是乘以2的移动位数次幂，
>>:其实就是除以2的移动位数次幂，
最高位补什么有原来数据最高位定，如果数据最高位为0，右移后，用0补空位；如果数据最高位为1，右移后，用1补空位。
>>>:无论最高位是什么右移后都用0补。

***3 与& 1&0=0; 0&1=0；0&0=0；1&1=1；
或| 1|1=1；1|0=1；0|1=1；0&0=0；
异或^ 1^1=0；10=1；0^{1=1；一个数异或一个数2次还是那个数（a}b^b=bb^a=a）
反码~ 6=0110 6的反码等于1001= -7
b=a++ 先赋值后自增1 b=++a 先自增1再赋值

***4 不用第三方变量使2个数的值交换
方法1：
n=n+m; //如果n和m的值非常大，那他们的和容易超出int范围。
m=n-m;
n=n-m;
方法2：
n=n^m;
m=n^m; //(n^m)m
n=n^m; //n⁽ⁿm)

***5 三元运算符：（条件表达式）？表达式1：表达式2

***6 switch选择语句
int x=3;
switch(x)//x只可以是byte short int char 四种类型
{
case 1：
System.out.println(“帆帆最可爱”);
break;
case 1：
System.out.println(“帆帆最漂亮”);
break;
case 1：
System.out.println(“帆帆最优秀”);
break;
default:
System.out.println(“帆帆最美丽”);
break;

	}
	
	int x=3;
	switch(x)//x只可以是byte short int char 四种类型
	{
		default:
		     System.out.println("帆帆最美丽");
			 //break;
		case 1:
		     System.out.println("帆帆最可爱");
			 //break;
		case 2:
		     System.out.println("帆帆最漂亮");
			 //break;
		case 4:
		     System.out.println("帆帆最优秀");
			 break;		 
	}
//default:这条语句移动到前面。则在case都不匹配的情况下，运行default语句，
如果该语句下面没有大括或者break，就一直运行下去忽略case。
//所以下面运行结果为（空格代表回车换行）：帆帆最美丽  帆帆最可爱  帆帆最漂亮  帆帆最优秀

***7 if和switch语句选择
如果判断的具体数值不多，而且符合byte short int char四种类型，建议使用swtich。因为效率高。
其他情况：对区间判断，对结果为boolean类型判断， 使用if语句

***8 while与do while区别
while： 先判断条件再执行循环体
do while： 先执行以此循环体再判断条件

***9 无限循环的最表达形式
1：for（；；）{ }
2：while(true){ }

***10 转义字符
\b: 退格(BS) ，将当前位置移到前一列
\f: 换页(FF)，将当前位置移到下页开头
\n: 换行(LF) ，将当前位置移到下一行开头
\r: 回车(CR) ，将当前位置移到本行开头
\t: 水平制表(HT) （跳到下一个TAB位置）

***11
public static void tobin (int a)
{
StringBuffer sb =new StringBuffer();//先存着数

	while(a>0)
	{
		sb.append(a%2);//存入
		a=a/2;
	}
	System.out.print(sb.reverse());//输出（加上.reverse（）输出110，不加输出011）
}

***12
跳出循环：break（结束这个循环）;continue（忽略某次）； return; （直接结束main()方法）

***13
匿名对象：使用方法一，当对对象的方法只调用一次时，可以用匿名对象来完成，这样写比较简化。
如果对一个对象进行多个成员的调用，必须给对象起个名字。
//car.c=new car();
//c.color=“blue”; 这两句可以简化为：new car().color=“blue”;
但是运行后就是垃圾
使用方法二，可以将匿名对象作为实际参数进行传递。
//car c=new car();
//show©; 这两句可以简化为:show(new car());
public static void show(car c)
{
c.num=3;
c.color=“bule”;
c.run();
}
***14
private：私有，权限修饰符：用于修饰类中的成员（成员变量，成员函数）。私有旨在本类中有效。
将某变量私有化后，类以外即使建立了对象也不能直接访问，
class haha
{
private int a；
public void seta（int b）//修改a
{
a=b；
}
public void geta（int b）//返回a
{
return a；
}
*****15
构造函数：**对象一建立就会调用与之对应的构造函数。构造函数作用：可以用于对对象的初始化。
构造函数的细节：当一个类中没有定义构造函数时，系统就会默认给该类加入一个空参数的构造函数。
当在类中自定义了构造函数后，默认的构造函数就没有了。
构造函数与一般函数区别
写法不同：格式问题。构造函数与类名一样person（）/一般函数public void name（）
运行不同：构造函数一建立就运行，给对象初始化；而一般函数是对象调用才执行，给对象添加或修改数据的功能。
一个对象建立，构造函数只运行一次；而方法可以反复调用
什么时候定义构造函数？
当分析事物时，该事物存在具备一些特性或行为，那么将这些内容定义在构造函数中。
【构造函数私有化后便不可以建立对象】
***16
构造代码块：作用：给对象进行初始化。
对象一建立就运行，而且优先于构造函数执行。
和构造函数的区别：构造代码块是给所有对象进行统一初始化（可以说免去后面重复书写的麻烦），而构造函数是给对应的函数进行初始化。
构造代码中定义的是不同对象共性的初始化内容。
{
cry（）；
//语句或者调用函数
} /放在所有构造函数的前面/
*****17
this：**看上去，是用于区分局部变量和成员变量同名情况。
代表他所在函数所属对象的引用。
简单说：那个对象在调用this所在的函数，this就代表那个对象。
***18
this语句：用于构造函数之间进行互相调用。（只能在构造函数中用）
this语句只能定义在构造函数的第一行，因为初始化要先执行。
*****19
valueOf()函数：**返回指定对象的原始值。
对象 返回值
Array 数组实例对象。
Boolean 布尔值。
Date 以毫秒数存储的时间值，从 UTC 1970 年 1 月 1 日午夜开始计算。
Function 函数本身。
Number 数字值。
Object 对象本身。这是默认设置。
String 字符串值。
*****20
大数类：**定义BigInteger a = new BigInteger(“2”)，定义大数a，初始化为大数 2 ，用字符串数字传参数，
大数加减乘除分别为 a.add(b),a.subtract(b),a.multiply(b),a.divide(b)。
比较a和b，a.compareTo(b)如果大于 0 说明 a>b。
***21
Scanner类中的方法next()和nextLine()区别：
next()不会吸取字符前/后的空格/Tab键，只吸取字符，开始吸取字符（字符前后不算）直到遇到空格/Tab键/回车截止吸取；
　 nextLine()吸取字符前后的空格/Tab键，回车键截止。
***22
static静态关键字
用法：是一个修饰符，用于修饰成员（成员变量，成员函数）
当成员被静态修饰后，就多了一个调用方式，除了可以被对象调用外还可以直接被类名调用。（类名.静态成员）
/static特点/ 1：随着类的加载而加载 也就是说静态会随着类的消失而消失
2：优先于对象存在 明确点就是静态是先存在，对象是后存在的
3：被所有对象所共享
4：可以直接被类名调用 person.country
实例变量和类变量的区别： 】 class person
1，存放位置：类变量随着类的加载而存在于方法区中 】{
实例变量随着对象的建立而存在于堆内存中 】 String name;//成员变量，实例变量
2，生命周期：类变量生命周期最长，随着类的消失而消失】 static Stting country=“中国”;//静态的成员变量，类变量
实例变量生命周期随着对象的消失而消失 】}
静态使用注意事项：
1，静态方法只访问静态成员；非静态方法即可以访问静态
2，静态方法中不可以定义this，super关键字；因为静态优先于对象存在，所以静态方法中不可以出现this，super。
***23
public static void main(String[] args)
主函数：是一个特殊的函数，作为程序的入口，可以被jvm（虚拟机）调用
主函数的定义：public：代表着这个函数的访问权限最大
static：代表随着类的加载就已经存在了
void：主函数没有具体返回值
main：不是关键字但是一个特殊的单词，可以被jvm识别
（String[] arr）：函数的参数，参数类型是一个数组，该数组中的元素是字符串
主函数是固定格式的：jvm识别 【数组定义方法】1，String[ ] arr={“haha”,“hh”,“heihei”}
jvm在调用主函数时，传入的是new String[[0]; 2, String[ ] arr=new String[x]
***24
什么时候使用静态？ 当对象中出现共享数据时，该数据被静态所修饰
对象中的特有数据要定义为非静态存于堆内存中
什么时候定义静态函数呢？当功能内部没有访问到非静态数据（对象的特有数据）那么该功能可以定义为静态的
***25
静态函数的应用（day6）
每一个应用程序中都有共性的功能可以将这些功能进行抽取独立封装，以便复用。
虽然可以通过建立ArrayTool的对象使用这些工具方法，对数组进行操作
发现问题：1，对象是用于封装数据的，可是ArrayTool对象并未封装特有数据
2，操作数组的每一个方法都都没有用到ArrayTool对象中的特有数据
所以为了更加严谨程序是不需要对象的。可以将ArryToll中的方法都定义成static的。
【将ArrayTool.class文件发给别人，别人只需要将该文件设置到classpath路径下，就可以使用该工具
***26
制作帮助文档 【必须将该类用public修饰才可以成功】
一个类中默认会有一个空参数的构造函数，这个默认的构造函数的权限和所属类一致
如果类被public修饰，那么默认的构造函数也带有public修饰符，反知类没有被修饰则构造函数也没有
***27
函数调用并不是在原地展开代码
每一个函数都是一段独立存在于存储器中的指令序列
每当你调用一次函数, 就会向栈中压入(push)返回地址, 当函数返回(return)时从栈中弹出(pop)返回地址并跳转回返回地址.
***28
Random类是java.util包中得一个类，专门用来产生各种类型得随机数；

使用该类必须先生成对象，再调用它的方法，Random类中所含方法大致如下：

方法 说明
boolean nextBoolean() 生成一个随机的 boolean 值，生成 true 和 false 的值概率相等
double nextDouble() 生成一个随机的 double 值，数值介于[0,1.0)，含 0 而不包含 1.0
int nextlnt() 生成一个随机的 int 值，该值介于 int 的区间，也就是 -231~231-1。如果 需要生成指定区间的 int 值，则需要进行一定的数学变换
int nextlnt(int n) 生成一个随机的 int 值，该值介于 [0,n)，包含 0 而不包含 n。如果想生成 指定区间的 int 值，也需要进行一定的数学变换
void setSeed(long seed) 重新设置 Random 对象中的种子数。设置完种子数以后的 Random 对象 和相同种子数使用 new 关键字创建出的 Random 对象相同
long nextLong() 返回一个随机长整型数字
boolean nextBoolean() 返回一个随机布尔型值
float nextFloat() 返回一个随机浮点型数字
double nextDouble() 返回一个随机双精度值
————————————————
public class Rand {
public static void main(String[] args) {
int[] arr = new int[30];
Random random = new Random();
for(int i=0; i<30; i++) {
arr[i] = random.nextInt(5+1)+10-5; //产生5~10之间的数
}
for(int i:arr) {
System.out.print(i+"、");
}
}
}
***29
java.util包被称为java工具包，里面包含大部分的工具类

一、Random 随机数类
new Random()
rd.nextInt()
rd.nextInt(100)

二、Scanner 扫描器类
Scanner sc = new Scanner(system.in);
String str = sc.next();
String str1 = sc.nextLine();
int t = sc.nextInt();
float t = sc.nextFloat();

三、Date 日期类
Date d = new Date(); 当前时间
Date d = new Date(long); 指定的时间
d.getTime();获得当前时间的毫秒数

四、日期格式化类
SimpleDataFormat 格式化日期时间的类
SimpleDateFormat sdf = new SimpleDateFormat(“yyyy-MM-dd HH:mm:ss E”);
String s = sdf.format(d);

五、Calendar 日历类
Calendar c = Calendar.getInstance();
int year = c.get(Calendar.YEAR);
int month = c.get(Calendar.MONTH);
int day = c.get(Calendar.DAY_OF_MONTH);
int hour = c.get(Calendar.HOUR_OF_DAY);
int min = c.get(Calendar.MINUTE);
int sec = c.get(Calendar.SECOND);
int w = c.get(Calendar.DAY_OF_WEEK);

ps：Calendar类是一个抽象类，需要通过getInstance()方法来实现

Calendar与Date类之间的转换分别是getTime()和setTime()

Calendar对象获取month将会比实际的月份少一个月，是从下标为0开始的

Calendar对象获取day_of_week是获取到当前星期，返回的是重这周日到当前礼拜的天数。

六、TimerTask 定时任务类
Timer 定时器
定义一个类继承TimerTask,重写run方法
创建一个Timer对象
创建一个xxTask对象
启动任务

在指定的时间指定任务
t.schedule(task, date);

延迟一定时间执行
t.schedule(task, 500);

延迟一定时间执行，每隔一定时间重复执行一次
t.schedule(task, 5000, 1000);

在指定的时间开始执行，每隔一定时间重复执行一次
t.schedule(task, d, 1000);

七、Arrays 数组类
binarySearch(数组,值) 用二分法查找值在数组中出现的下标位置，前提条件，数组必须是有序的
sort(数组) 对数组用快排法进行排序
toString(数组) 将数组转换成字符串形式
copyOf(数组,长度)拷贝数组，得到一个新数组
附：控制台日历查询程序

***29利用Array类中的toString方法
调用Array.toString(a)，返回一个包含数组元素的字符串，这些元素被放置在括号内，并用逗号分开

int[] array = {1,2,3,4,5};
System.out.println(Arrays.toString(array));
输出：[1, 2, 3, 4, 5]
————————————————

***30

“&&”与“||”，前者第一个条件不成立，后面的条件均不进行判断，返回false；第一个条件成立再判断下一个
后者第一个条件成立，后面的条件均不进行判断,返回true，第一个条件不成立继续判断下一个

***31
Integer.toString() 方法 进制转换
public static String toString(int i, int radix){
System.out.println(Integer.toString(i, radix));//十进制转radix进制
Integer.parseInt((String) s,(int) radix);//radix进制转10进制
}

将 int 转换为 String，以 radix 为进制
***32
charAt() 方法可返回指定位置的字符。
***33
System.currentTimeMillis()；输出当前计算机时间（以毫秒为单位的）
***34
静态代码块：对类进行初始化
static{
静态代码块中的执行语句。
}
//特点：随着类的加载而执行只执行一次，并优先于主函数，优先于构造代码块。
Person P = new Person (" zhangsan",20) ;
该句话都做了什么事情?
1,因为new用到了person. class.所以会先找到person.class文件并加载到内存中。
2,执行该类中的static代码块， 如果有的话，给Berson. class类进行初始化
3，在堆内存中开辟空间，分配内存地址.
4，在堆内存中建立对象的特有属性。并进行默认初始化。
5，对属性进行显示初始化。
6，对对象进行构造代码块初始化.
7,对对象进行对应的构造函数初始化。
8,将内存地址付给栈内存中的p变量.
***35
设计模式: 解决某一类问题最行之 有效的方法。
单例设计模式: 解决一- 个类在内存只存在一一个对象。
想要保证对象唯一。
1,为了避免其他程序过多建立该类对象。先禁止其他程序建立该类对象
2,还为了让其他程序可以访问到该类对象，只好在本类中，自定义一个对象。
3，为了方便其他程序对自定义对象的访问，可以对外提供一 些访问方式。
这三部怎么用代码体现呢?
1，将构造函数私有化。
2,在类中创建一个本类对象。
3,提供一个方法可以获取到该对象。
对于事物该怎么描述，还怎么描述。
当需要将该事物的对象保证在内存中唯一时， 就将以上的三步加上即可。
***36
【extends继承】
将学生和工人的共性描述提取出来，单独进行描述,
只要让学生和工人与单独描述的这个类有关系，就可以了。
*继承:
1,提高了代码的复用性.
2，让类与类之间产生了关系。有了这个关系，才有了多态的特性。
*注意:千万不要为了获取其他类的功能，简化代码而继承。
必须是类与类之间有所属关系才可以继承。所属关系is a.
那么这个体系已经可以基本使用了。
那么在具体调用时，要创建最子类的对象，为什么呢?
一是因为有可能父类不能创建对象，
二: 是创建子类对象可以使用更多的功能，包括基本的也包括特有的。
简单一句话:查阅父类功能，创建子类对象使用功能。

Java语言中: java只支持单继承，不支持多继承。
因为多继承容易带来安全隐患:当多个父类中定义了相同功能，
当功能内容不同时，子类对象不确定要运行哪一个 .
但是java保留这种机制。并用另一种体现形式来完成表示。多实现。
java支持多层继承也就是一个继承体系
如何使用一个继承体系中的功能呢?
想要使用体系，先查阅体系父类的描述，因为父类中定义的是该体系中共性功能.
通过了解共性功能，就可以知道该体系的基本功能.
那么这个体系已经可以基本使用了。
那么在具体调用时，要创建最子类的对象，为什么呢?
一是因为有可能父类不能创建对象，
二: 是创建子类对象可以使用更多的功能，包括基本的也包括特有的。
简单一句话:查阅父类功能，创建子类对象使用功能。
***37
子类中【变量】的特点 （super关键字）
如果子类中出现 {非私有的} 同名成员变量a时，直接打印变量a后值为子类的值
子类要访问本类中的变量，用this
子类要访问父类中的同名变量，用super.

super的使用和this的使用几乎一致。
this代表的是本类对象的引用。
super代表的是父类对象的引用.
***38
子父类中的【函数】特点。
当子类出现和父类一模一 样 的函数时，
当子类对象调用该函数，会运行子类函数的内容。
如同父类的函数被覆盖一样。

这种情况是函数的另一个特性:【重写(覆盖)】

当子类继承父类，沿袭了父类的功能，到子类中，
但是子类虽具备该功能，但是功能的内容却和父类不致，
这时，没有必要定义新功能，而是使用覆盖特殊，保留父类的功能定义，并重写功能内容。
【覆盖】:
子类覆盖父类，必须保证子类权限大于等于父类权限，才可以覆盖，否则编译失败。
2,静态只能覆盖静态.
记住大家:
重载:只看同名函数的参数列表。
重写:子父类方法要一模一样.
***39
3，子父类中的【构造函数】的特点。
在对子类对象进行初始化时，父类的构造函数也会运行，
那是因为子类的构造函数默认第一行有一条 隐式的语句super();
super() :会访问父类中空参数的构造函数。而且子类中所有的构造函数默认第一行都是super () ;

为什么子类一定要访问父类中的构造函数。

因为父类中的数据子类可以直接获取。所以子类对象在建立时，需要先查看父类是如何对这些数据进行初始化的。
所以子类在对象初始化时，要先访问一下父类中的构造函数。
如果要访问父类中指定的构造函数，可以通过手动定义super语句的方式来指定。

注意:super语句一定定义在子类构造函数的第一行.

子类的实例化过程。
【结论】:
子类的所有的构造函数，默认都会访问父类中空参数的构造函数。
因为子类每一- 个构造函数内的第一行都有一句隐式super();
当父类中没有空参数的构造函数时，子类必须手动通过super语句形式来指定要访间父类中的构造函数。
当然:子类的构造函数第一行也可以手动指定this语句来访问本类中的构造函数。
子类中至少会有一一个构造函数会访问父类中的构造函数.
***40
final :最终。作为一个修饰符，
1，可以修饰类，函数，变量。
2，被final修饰的类不可以被继承。为了避免被继承，被子类复写功能。
3，被final修饰的方法不可以被复写，
4,被final修饰的变量是一一个常量只能赋值一次，既可以修饰成员变量，有可以修饰局部变量。
当在描述事物时，一些数据 的出现值是固定的，那么这时为了增强阅读性，都给这些值起个名字。方便于阅读。
而这个值不需要改变，所以加上final修饰。
5，内部类定义在类中的局部位置.上是，只能访问该局部被final修饰的局部变量。
***41
【抽象类】abstract 关键字
当多个类中出现相同功能，但是功能主体不同，
这是可以进行向上抽取。这时，只抽取功能定义，而不抽取功能主体。
抽象:看不懂。
抽象类的特点:
1,抽象方法一定在抽象类中。
2,抽象方法和抽象类都必须被abstract关键字修饰。
3,抽象类不可以用new创建对象。因为调用抽象方法没意义.
4，抽象类中的抽象方法要被使用，必须由子类复写起所有的抽象方法后，建立子类对象调用.
如果子类只覆盖了部分抽象方法，那么该子类还是一个 抽象类。
***42
抽象:看不懂。
抽象类的特点:
1,抽象方法一定在抽象类中.
2,抽象方法和抽象类都必须被abstract关键字修饰.
3，抽象类不可以用new创建对象。因为调用抽象方法没意义。
4，抽象类中的抽象方法要被使用，必须由子类复写起所有的抽象方法后，建立子类对象调用。
如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象类。
抽象类和一般类没有太大的不同。
该如何描述事物，就如何描述事物，只不过，该事物出现了一些看不懂的东西。
这些不确定的部分，也是该事物的功能，需要明确出现。但是无法定义主体。
通过抽象方法来表示。

抽象类比一般类多个了抽象函数。就是在类中可以定义抽象方法。
抽象类不可以实例化。

特殊:抽象类中可以不定义抽象方法，这样做仅仅是不让该类建立对象。
***43
【模版方法】
需求:获取一段程序运行的时间。
原理:获取程序开始和结束的时间并相减即可。
获取时间: System. currentTimeMillis() ; I
当代码完成优化后，就可以解决这类问题=
这种方式，模版方法设计模式。

什么是模版方法呢?
在定义功能时，功能的一部分是确定的，但是有一部分是不确定，而确定的部分在使用不确定的部分，
那么这时就将不确定的部分暴露出去。由该类的子类去完成。
***44
【接口】implements关键字 实现（和extends差不多）
interface Inter{
public static final int NUM = 3;
public abstract void show() ;
}
class Test implements Inter{
public void show() { }
}

class用于定义类
【interface】用于定义接口。
接口定义时，格式特点:
1，接口中常见定义:常量，抽象方法。
2,接口中的成员都有固定修饰符。
常量: public
static final
方法: public abstract
理住:接口中的成员都是public的。
接口:是不可以创建对象的，因为有抽象方法。
需要被子类实现，子类对接口中的抽象方法全都覆盖后，子类才可以实例化。
否则子类是一个抽象类。

接口与接口之间可以进行多extends继承，接口与类之间可以进行多implements实现，类与类之间只可以进行单继承
因为类与类之间可能存在重名的函数导致虚拟机不知道运行哪一个，接口都是模糊的没有实质性的内容可以多继承
***45
接口的特点
1接口是对外暴露的规则。
2接口是程序的功能扩展。
3接口可以用来多实现。
4类与接口之间是实现关系，而且类可以继承一个类的同时实现多个接口。
5接口与接口之间可以有继承关系。