笔记为自学时随手记录，如有错误，欢迎指正，不胜感激！现已广州转移至上海，欢迎小伙伴们加qq或微博沟通交流（QQ，微博和博客同名）
笔记分享：自学it18大数据笔记-第一阶段Java-day03-day04——会持续更新……
day03笔记见下图：
day04笔记见下图：
Day03
回顾
echo %classpath% 查看classpath
float x=100.0f 要强转 降级
函数 function，方法method 封装功能代码 不能嵌套定义
函数的格式
修饰符 返回值类型 函数名(参数类型 形式参数1，参数类型 形式参数2，...)
{
执行语句;
return 返回值;
}
返回值类型：函数运行后的结果的数据类型。
参数类型：是形式参数的数据类型。
形式参数：是一个变量，用于存储调用函数时传递给函数的实际参数。
实际参数：传递给形式参数的具体数值。
return：用于结束函数。
返回值：该函 数运算后的结果，该结果会返回给调用者
函数就像个黑匣子 有输入：参数 就有输出：返回值（没有返回值void） 所以函数2个明确就是知道进去什么，要出来什么！
######
有种 参数个数不确定情况：int...arg
Function的调用
============
函数名（实参） 可以无参
=================
\n是换行，英文是New line，表示使光标到行首
\r是回车，英文是Carriage return，表示使光标下移一格
\r\n表示回车换行
\t Tab键
函数的重载overload
-----------------
Recursive递归 很多命令带参 –R 就是递归的意思 尤其是文件夹的操作的时候
Fabric阶乘
################
+++++++++++++++
数组array
---------------------------------------------
同一种类型数据的集合，容器 以0为基址
格式：
元素类型[] 数组名 = new 元素类型[元素个数或数组长度]; 固定长度
示例：int[] arr = new int[5]; arr.length数组的长度 length是属性不是方法
元素类型[] 数组名 = new 元素类型[]{元素，元素，……};
int[] arr = new int[]{3,5,1,7};
int[] arr = {3,5,1,7};
Java没有显式的指针操作 引用就是它指针 指针是对象的内存地址！
Null 对象不存在，不能访问起属性和方法
内存的结构
对象和数组都在 堆 里面 通过new创建的实体 都有内存地址 都有默认的初始化值
栈存储局部变量 使用完就释放
方法区
本地方法区
寄存器
数组排序
选择排序 依次后比 选出最小（大）放在最前 2个for的顺序相同
class ArrayDemo{
public static void main(String[] args){
int[] arr = {34,46,53,44,56};
for(int i=0; i<arr.length-1; i++){
for(int j=i+1; j<arr.length ; j++){
if(arr[i] > arr[j] ){
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
}
//增强for
for( int ii :arr){
System.out.print(ii + " ") ;
}
System.out.println();
}
}
冒泡排序 2个比较 每一轮就把最大的沉底了（放在最后）==大数沉底 2个for的循序相反
class ArrayDemo{
public static void main(String[] args){
int[] arr = {34,46,53,44,56};
for(int i=arr.length-1; i>0; i--){
for(int j=0; j<i ; j++){
if(arr[j] > arr[j+1] ){
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
//增强for
for( int ii :arr){
System.out.print(ii + " ") ;
}
System.out.println();
}
}
增强for循环
For（带参变量：数组）==变量依次取得数组中的元素
索引就是排了序的数据
折半查找（二分查找）
在有序的数列中，进行二分查找，每次取出搜索范围的中间值进行比较，依次再进行范围的缩小，直至找到所需的值。
class HalfFind{
public static void main(String[] args){
int[] arr = {33,44,35,55,36,53,43,77,66,52};
int[] arr0 = ArrStort(arr);
//增强for
for( int ii :arr0){
System.out.print(ii + " ") ;
}
System.out.println();
System.out.println("-------------------------------------------");
int num = 77;
int index = -1;
int min = 0;
int max = arr.length - 1;
while(min <= max){
int mid = (min + max) / 2;
if(arr[mid] == num){
index = mid;
break;
}
else if(arr[mid] > num){
max = mid - 1;
}
else{
min = mid + 1;
}
}
System.out.println(index);
}
public static int[] ArrStort(int[] arr){
for(int i=0; i<arr.length-1; i++){
for(int j=i+1; j<arr.length ; j++){
if(arr[i] > arr[j] ){
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
}
return arr;
}
}
二维数组【】【】 数组的数组
格式1：int[][] arr = new int[3][2];
格式2：int[][] arr = new int[3][];
格式3：int[][] arr = {{3,8,2},{2,7},{9,0,1,6}};
注意特殊写法情况：int[] x,y[]; x是一维数组，y是二维数组。
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Day04
回顾作业： 一个字节byte转换成0~255之间的整数 用到 &
Byte b = 100;
Int I = b & 0xff;
面向对象 OOP 一切都是对象
OOP：Oriented object program 面向对象编程
OOA：Oriented object analyze 面向对象分析
OOD：Oriented object design 面向对象设计
C语言是面向过程的，
Entity实体 new在创建对象中常用 分派空间 开发就是不断创建对象 适用对象
面向对象特征：封装encapsulation 继承inheritance 多态polymorphism
类
---------------
物以类聚
对现实事物的软件抽象。 对象就是切实存在的个体
类和对象 就是图纸和汽车的关系
类就是图纸
汽车就是堆内存中的对象
========================================
生活中描述事物无非就是描述事物的属性和行为。
如：人有身高，体重等属性，有说话，打球等行为。
Java中用类class来描述事物也是如此
属性：对应类中的成员变量。
行为：对应类中的成员函数。
定义类其实在定义类中的成员(成员变量和成员函数)。
====================================
类成员 相对的概念
---------
1，成员变量 属性property==字段field 数值类型的基本默认为0
2，成员函数 方法
3，定义方式 class 类名 //首字母大写，或 $_ 其他都不能用
堆heap：数组和对象在堆中
栈stack：函数方法在栈中 局部变量在在栈中
（局部变量 是函数或语句内部的变量，在栈中 没有初始值 定义局部变量必须初始化 || 成员变量 是对象类中在整个类中都可以被访问 在堆中 有默认的初始值）
局部变量是对成员变量的一个应用 通过内存地址
Java vm调整堆大小
----------------------------------------------------------------------
默认jvm分配的栈空间大小是1m
默认jvm分配的堆空间的最大值是1/4物理内存。
Java –X //查看Java非标准输出帮助
Java –Xmx100m //设置jvm的堆空间最大值
Java –Xms100m //设置jvm的堆空间初始值
======================================================================
查看运行的java进程
jps [-v] //显示可提取pid
查看指定java进程的堆空间
jmap -heap pid //jmap也是jdk自带工具
//linux下切换到root。
java中对象和数组位于堆内存中，局部变量、函数参数等位于栈内存中。
=======================================================================
匿名对象 用完就扔 不在需要用一个变量来保持了
--------------------------------------------
是对象的简化形式
两种使用情况
当对对象方法仅进行一次调用的时 new Person().run();
匿名对象可以作为实际参数进行传递 run（new Person（））；
封装 encapsulation 将部分成员隐藏起来，外界只能通过其他方式进行访问，使用private进行修饰，保证安全性。
-------------------------------------------------
原则：
将不需要对外提供的内容都隐藏起来。
把属性都隐藏，提供公共方法对其访问。
Public---private 完全公开---完全私有：两个极端——用到最多的2个修饰符
====================================================================
private关键字：是一个权限修饰符。用于修饰成员(成员变量和成员函数)，被私有化的成员只在本类中有效。
常用之一：
将成员变量私有化，对外提供对应的set ，get方法对其进行访问。提高对数据访问的安全性。
构造函数 函数的一种！ 给对象进行初始化——创建对象的时候使用的
-----------------------------------------------------------------------------------------------------------
1，函数名和类名相同（正常函数名首字母小写并且有返回值——有值就有类型，或void）
2，没有返回值（有值就有类型：无值无类型）
默认构造函数是无参的，多个构造函数是重载的形式存在的
3，如果类没有定义构造函数，jvm分配一个空构造；如果类定义了构造函数，就不会自动分配空构造，需要自己给出！！！
代码块 代码中使用单独的{}围起来的内容。
-------------------------------------------------------------------------------------------
构造代码块：类的成员之一；创建对象时调用（创建1个对象就调用1次），先于构造函数调用。
局部代码块：方法内定义的代码块
静态代码块：使用static修饰的代码构造块，在类的加载时实行并只调用一次，以后不再调用。通常放置对静态成员变量的初始化过程——在类中函数和代码块中最先执行，只执行一次！
类中：1，静态成员和对象无关
2，静态成员只能访问静态成员，无法访问非静态成员——非静态成员可以访问静态成员
3，静态成员存在内存中的方法区中
Main函数中可以通过类直接访问某类的静态成员 （静态成员和对象无关） static和对象无关只和类相关
========================================================================
static关键字：用于修饰成员（成员变量和成员函数）
被修饰后的成员具备以下特点：
随着类的加载而加载
优先于对象存在
被所有对象所共享
可以直接被类名调用
使用注意：
静态方法只能访问静态成员
静态方法中不可以写this，super关键字
主函数是静态的
=========================================================================
类成员 对比
-----------------------------------------------------
成员变量 局部变量
成员函数 局部函数
构造函数
构造代码块 局部代码块
静态代码块
Javabean
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
This.xxx 指向对象自身的指针（引用） 类似private修饰的成员变量
-----------------------------------------------------
特点：this代表其所在函数所属对象的引用。换言之：this代本类对象的引用。
什么时候使用this关键字呢？当在函数内需要用到调用该函数的对象时，就用this。
This（）
-----------------------------------------------------
访问当前类的构造函数 重用（复用）
This（）的调用必须是构造函数的第一条语句！
为了构造函数的重用
Super（）
----------------------------
访问超类的构造函数
必须是第一行代码
构造函数的首行要么是this（），要么是super（）。默认是super（）
Super.xxxxxx 访问超类的成员
----------------------------------------
super和this的用法相像：this代表本类对象的引用；super代表父类的内存空间的标识。
当子父类出现同名成员时，可以用super进行区分
子类要调用父类构造函数时，可以使用super语句——就是super（）的用法。
继承 extends （单词加s 是因为类都是第三人称单数）
-------------------------------------------------------------
多个类可以称为子类，单独这个类称为父类或者超类。
子类可以直接访问父类中的非私有的属性和行为。
通过 extends 关键字让类与类之间产生继承关系。
class SubDemo extends Demo{}
继承的出现提高了代码的复用性。
继承的出现让类与类之间产生了关系，提供了多态的前提。
===========================================================
Java只支持单继承，不支持多继承。
一个类只能有一个父类，不可以有多个父类。
class SubDemo extends Demo{} //ok
class SubDemo extends Demo1,Demo2...//error
Java支持多层继承(继承体系)
class A{}
class B extends A{}
class C extends B{}
定义继承需要注意：1，不要仅为了获取其他类中某个功能而去继承；2，类与类之间要有所属( " is a " )关系，xx1是xx2的一种——狗是动物的一种。
函数覆盖 override 重写overwrite 继承的时候才有！
---------------------------------------------------------------------------------------------------------------------------
1，子类中出现与父类一模一样的方法时，会出现覆盖操作，也称为重写或者复写。
2，父类中的私有方法不可以被覆盖。
3，在子类覆盖方法中，继续使用被覆盖的方法可以通过super.函数名获取——就是super.xxx的使用。
覆盖注意事项：
覆盖时，子类方法权限一定要大于等于父类方法权限
静态只能覆盖静态。非静态覆盖非静态，静态性约束保持一致。
覆盖的应用：
当子类需要父类的功能，而功能主体子类有自己特有内容时，可以复写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容。
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++