发表于 | 分类于

包packge（可以理解为是一个文件夹）

在我们类的第一行会出现package关键字
如果package和import同时出现
先写package后写import
package只能有一个import可以有多个

类的关系

has-a

        包含关系（组合 聚合 关联） 语义
        从亲密程度来讲不太一样
        组合--->人的大脑  人和心脏的关系
             整体和部分的关系 不可分割 要出现整体出现 要消亡整体消亡
        整合---->汽车和轮子 电脑和主板
             整体和部分的关系 创建时可能是分开的
        关联---->人有汽车 人有电脑
             整体和部分的关系 可以分割后来形成一起
        从Java程序来描述这样的关系 通过一个类的对象当做另一个类的属性来存储

ues a     (need a ) 依赖关系

屠夫 杀 猪
           可以做一件事情 杀猪
           需要一头猪
不是整体和部分的关系 某一件事情产生关系
临时组合在一起 这件事情一旦做完关系就解散
通过在方法中引用另一个类的对象实现

发表于 | 分类于

高级标签

空格标签      
左尖括号     <   less than
右尖括号     >   great than
换行        <br>
划线        <hr>

有序列表

  <ol>  
     <li>苹果</li>
     <li>香蕉</li>
     <li>菠萝</li>
   </ol>  
有序表属性
  <ol type ="a"(a,A,1,i,I)  reversed = "reversed"  start = "3">
  //排序可以按a，A，1,罗马小写i，罗马大写 i reversed属性表示倒序 start表示起始顺序

*无序表

<ul>
   <li>Marvel</li>
   <li>返老还童</li>
   <li>了不起的盖茨比</li>
 </ul>
<ul type = "disc" (square circle)>
//标签是实心圆 实心方块 空心圆

超文本链接

<a herf " " >www.baidu.com</a>
 //hyperText reference 
  数字 文字 图片均可以跳转 target在当前页面打开 blank打开新页面
  <打电话>  <a herf="tel:">
  <发邮件>  <a herf="mailto">
  <协议限定符>
  //<a herf="javascript=while(1）{alert（"让你手欠"）} 你点我试试呀！come on 来呀！</a>

图片标签

    <img src="url">
//可以打开网络url；本地绝对路径；本地相对路径
 alt属性图片占位符（图片出错时显示信息）     
title属性图片提示符（光标移动到图片显示）

锚点

anhor（实现置顶）记录位置

表单

<form method="get/post" action="">
<input type="text"  name="username">
<input type="password" name="password">
<input type="submit" value="login">
</form>
// 发送数据 需要数据名和数据内容两项
  提交检验 pro/Desktop/lesson2.html?username=sunny&password=123123.
  md5协议进行加密         123123
                     加密后&@#￥&￥
<input type ="radio">单选

发表于 | 分类于

类和类之间的关系

A is a B 泛化 （继承 实现）

A has a B 包含 （组合 聚合 关联）

A use a B 依赖 （依赖）need a

继承

1.子类继承父类，通过一个关键字 extends
2.子类的对象可以调用父类中的（public protected）属性和方法
3.子类可以添加自己的属性和方法
4.子类从父类继承过来的方法不能满足子类的需要，可以在子类中重写父类的方法 指内容重写
5.每一个类都有一个继承类，如果extrends关键字不写，默认继承Object类
6.java中继承是单个存在的（单继承）每一个类都只能有一个继承类（在extrends后面写一个类）目的是让类变得更安全，可以通过传递方式实现多继承的效果，后续还有多实现
7.继承在内存中的存储形式
8.关于this和super的使用

方法重写与重载

   方法重写override                                 方法重载overload
1.   产生两个继承关系的类                          一个类中的一组方法
     子类可以写父类的方法
2.特征符  
          final static abstract                          没有要求    
      父类方法是 final  子类不能重写
      父类方法是 static 子类不存在
      父类方法是 abstract 子类必须重写
3.权限修饰符 
        子类可以大于等于父类                             没有要求
4.返回值  
        子类可以小于等于父类                             没有要求
5.参数     
        子类父类必须一致                          每一个方法参数必须不一致
6.名字    
        子类父类必须一致                          一个类中的方法名必须一致
7.异常      
           运行时 编译时
    如果父类方法抛出运行时异常：                         没有要求
    子类可不予理会
    如果父类方法抛出编译时异常：
    子类抛出异常的个数和类型都少于等于父类
8.方法体   子类方法内容和父类不一致              每个重载方法执行过程不一致

Object类

        Object类是所有类的父类 Object类没有父类
        Object方法 
        1.toString方法 打印输出一个对象变成字符串
        public String toString() {
    return getClass().getName() + "@" + Integer.toHexString(hashCode());
}
        2.hashcode（）将对象的地址在内存中计算得到一个整数
        3.equals（）用来比较两个对象的内容
         == 和equals的区别
         equals方法是Object类中继承的方法 默认比较地址
         ==可以比较基本类型比较（值）也可以用来比较引用类型比较（地址）
         如果想要改变规则可以方法重写
          public boolean equals(Object obj) {
    return (this == obj);
}
        4.getclass（）   获取对应类的映射
        5.wait（）      线程进入挂起等待状态
        6.notify（）     唤醒线程
        7.notifyAll（）   唤醒所有
        8.finalize      权限修饰符 protected在对象被GC回收时默认执行方法 相当于C++析构函数
        9.clone（）     权限修饰符 protected为了克隆对象

this和super的使用

1.this和super都是指代词 代替的是对象
2.this代替的是当前执行方法时的那个对象 不一定是当前类的
  super代替的是当前执行方法时父类的那个对象 空间内部那个
3.都能调用一般属性和方法
4.可以放在类成员的任一位置（属性，方法，构造，块）
5.注意调用一般方法的时候来回调用（写法编译好用）执行可能产生问题 （stack overflow error）
6.可调用构造方法（放在构造方法的第一行）
7.this和super在构造方法中调用另一个类的构造方法不能出现在第一行
8.构造方法之间不能用来互相调用（编译不好用）

upload successful

发表于 | 分类于

HTML 基础标签

html （hyper text markup language） 超文本标记语言

<html lang = "en">
<head>
     <meta charset = "utf-8">
     <title> hello！new friend！</title>
</head>
< body>
      Life is full of hope!
      生活充满希望！
</body>
</html>

基础标签

根标签 <html> </html>
头标签 <head> </head>   浏览器设置
内容标签 <body> </body>  用户可见
属性标签 <meta>       可对关键字赋值
标题标签 <title> </title> 设置浏览器角标
段落标签 <p> </p>
字号标签 <h1-6> <h1-6>   由大到小
加粗标签 <strong> </strong>
斜体标签 <em> </em>     斜体
中划线标签 <dek> </del>
地址标签 <adress> </adress>
容器标签 <div> </div>    换行 结构化 分块明确 捆绑操作
         <span><sapn>

字符集

gb2312    只收录简体
gbk      包含繁体
unicod    万国码
utf -8    Unicode transformation format 第八版
lang = "en" en表示英语 中文 zh

发表于 | 分类于

面向对象的编程思想

类——–抽象的 属性（特征）和方法（行为）

对象—–具体的

描述一个类

属性
权限修饰符  {特征修饰符}  数据类型  属性名字  {=值}
方法
权限修饰符  {特征修饰符}  返回值类型 方法名字（参数列表）  {抛出异常} {{方法体}}；

创建一个对象

new  
对象     调用属性   存值/取值
对象.方法  调用方法   执行一次  （存储 执行）

类的加载

对象的创建
属性及方法的存储
方法的执行
方法执行的过程中  参数返回值的传递{基本数据类型  引用数据类型的区别}

方法的重载 overloard

1.概念：一个类中的一个一组方法  相同的方法名字 不同的参数列表  构成了方法的重载
参数的不同体现在  参数的个数 参数的类型 参数的顺序 三个方面
2.作用为了便于记忆和调用 使得方法调用的时候更加的灵活
3.自己也可以设计方法的重载
  调用的时候 先通过方法的名字来定位
  名字一致 通过参数列表的数据类型来定位
  方法返回值  修饰符 ---- 与方法重载无关
4.JDK1.5之后的  新写法 动态参数列表 ... 
  参数类型固定  参数的个数可以动态  0-n
  使用起来类似于数组的使用 length index
  int...x    int[][] x
  动态参数列表的方法   对应匹配的数组类型的方法不能构成重载（本质上是一样的）
  动态参数列表在方法的参数中只能存一份  且放置在参数的末尾

构造方法 —–做事情

1.作用：只有一个  构建（构造）当前类的对象
2.写法：   权限修饰符  与类名一致的方法名 （参数列表）{抛出异常}{方法体}
3.用法  通过new关键字调用
4.特点：
      （1）每个类都有构造方法：若自己的类中没有定义系统会默认提供一个无参的构造方法，若在类中定义了构造方法，则默认无参的狗造方法被覆盖
      （2）构造方法存值方法重载
5.每个类都提供一个构造方法  在创建对象的时候想做一些事情可以用构造方法

程序块 （代码块）

1.作用：跟普通方法一样 做事情的
2.写法：可以认为程序块是一个 没有修饰符 没有参数 没有返回值 没有名字的特殊方法{
}
3.用法：块需要调用才执行 我们自己调用不到（没有名字）
每次我们调用构造方法之前系统就会调用一次程序块（让他执行一遍）
4.特点：没有什么重载的概念 但可以在类中定义多个程序块
5.可以在里面写一些程序 我想要在创建对象之前执行

this关键字的使用

1.是一个关键字  代替某一个对象 （当前调用属性或方法时的那个对象）
2.this 既然指代一个对象
  this 可以调用 属性 方法
  this 可以调用构造方法  通过this();省略了构造方法的名字（必须与类名一致） 必须放在程序第一行
  一般方法不能调用构造方法

Scanner类

              1.导包               java.util
              2.创建对象         Scanner input = new Scanner(System.in);
              3.做事情          int value = input.nextInt（）;
                                String value = input.nextLine();
            -------------------------------------------------------------------------- 
            nextInt（nextFloat nextByte）next nextLine
1.读取方式上  大家都以回车符作为结束符号
          除了nextLine以外其余方法都不读取回车符
2.读取的返回结果来讲    nextInt--->int   nextFloat----float  nextLine---String  next--string
            next 方法看到回车或空格都认为结束 
              输入  abc def  g
              输出  abc
             nextLine 只认回车是结束符
              输入 abc def g
              输出 abc def g

利用包装类做string与基本类型的转化问题

int value = Interger.parseInt("");

发表于 | 分类于

转义字符

\转义字符 将身后的一个字符意思发生转换
 转换特殊符号   比如 " ' \
 转换几个特殊的字母 比如 \n换行  \r回车 \t制表符

main方法

public static void static (String[] args){
}
public 访问权限修饰符  公有的
staric  特征修饰符  静态的 有且只有一份
void   关键字   方法执行完没有返回值
main()  方法名称  主要的
主方法中的参数args参数  可否传递？
1.主方法不是我们调用的 JVM虚拟机启动的时候 虚拟机调用的
2.主方法里面有args参数 是一个String[]类型 我们可以传递参数进去给JVM

命名规则和规约

规则

字母 数字 符号 中文
字母 区分大小写
数字 不能开头
符号 _$
中文 不推荐

规约

类名字  首字母大写 两个单词以上 每一个首字母都大写
      Test TestOne TestTwo 
属性/方法/变量 驼峰式命名规约 首字母小写 两个单词以上 第二个以后的每个首字母大写
构造方法  与类名一致 类中唯一的大写字母开头的方法
静态常量  全部字母大写 通过 做具体说明 BOOKSTORE ADMIN
包名    全部字母小写 java关键字都是小写 注意与关键字不要冲突

发表于 | 分类于

多维数组

数组的特点

数组本身是一个引用类型
声明时必须指定长度  长度一旦确定就不能再次发生改变

定义/声明

里面存储的类型[] 数组名字;
int[][]  arry;

初始化

静态---有长度 有元素
  int[][] arry = {{1,2},{1}.{1.2.3}};
动态---只有长度 没有元素（默认值）
  int[][] arry = new int[3][2];
  arry ----->{{x,x},{x,x},{x,x}}  x默认值是0

元素访问

通过元素在数组中的位置----index
array[i][j]
i控制大数组中 小数组的位置
j控制小数组中 元素的位置

遍历轮循

正常for 增强for  嵌套完成

引用类型在内存中的结构

二维数组在内存中的存储，逻辑结构不是矩阵而是树
int[][] arry = new int[3][2];
//3表示有3个小数组int[]
//2表示每一个小数组有两个元素
//NullPointerException    空指针异常

常见的运行时异常

1.InputMisMatchException   输入类型不匹配 
     input.nextInt();      如：输入一个a
2.ArrayIndexOutOfBoundsException  数组索引越界
  静态初始化 int array[]={10,20};
             array[2]  //索引超过边界
3.NegativeArraySizeException  数组长度不合法（长度出现负数）
  动态初始化 int[] array = new int [-2]
4.NullPointerException    空指针异常 
   引用为null 还拿来使用就不行啦
   int[] arry = null;
   arry[0] = 10 ;//空元素再来用

发表于 | 分类于

数组（容器）

数组是一组数据类型相同的数据的组合，将这些数据统一管理起来
数组本身是一个引用数据类型，但数组内可以存储基本数据类型，也可以存储引用数据类型

数组的定义（声明）

数据类型[] 数组名字;
    int[] a;
    char[] b;
    boolean[] c;
    string[] m;

数组的（赋值）初始化

静态初始化    有长度 有元素
    int[] arry = {10,20,30,40,50,60};
    int[] arry = new int[] {10,20,30,40,50,60};
动态初始化    有长度   没有元素（默认值0）
    int[] arry = new int[5] ;
    整数默认值-----0
    浮点数默认值---0.0
    字符型默认值----0--char  97-a 65-A 48-'0'
    布尔型默认值----false
    引用数据类型默认值----null

数组元素的访问

通过元素在数组中的位置来访问
存值/取值
位置------->index索引
索引是有取值范围    [从0开始------到数组长度减1]
如果数组的索引超过了上诉范围
会出现了一个运行时的异常
ArrayIndexOutOfBoundsException

数组元素的遍历

通过循环的方式访问数组每一个元素
for（;;）{

}
JDK1.5版本之后 增加新特性 增强for循环 加强for forEach
for（自定义的变量（接收数组内每一个元素）：遍历的数组arry）{
}
1.正常的for循环 有三个必要的条件 找到一个元素的位置
可以通过index直接访问数组的某一个位置 存值 取值都可以
不好在于写法相对比较麻烦
2.增强for 有两个条件 用来取值的变量 用来遍历的数组 没有index索引 
写法相对容易
只能取值 不能存值
没有index索引  找不到元素是哪一个

基本数据类型和引用数据类型在内存结构上的区别

所有的变量空间都存储在栈内存
变量空间可以存储基本数据类型  也可以引用数据类型
如果变量空间存储的是一个基本数据类型  存储的是值 一个变量改变 另一个不会改变
如果变量空间存储的是引用数据类型 存储的是引用（地址）一个变量地址改变 另一个跟着改变

发表于 | 分类于

java运算符

运算符：用来指明操作数的运算方式

按照操作数的数目来分类

单目运算符    a++
双目运算符    a+b
三目运算符    (a>b)? x : y

按运算符的功能来分类

算数运算符   
+ - * / %（取余 求模）
++（自增） --（自减）
int x=1；
int y=x++；//++在后 先赋值 再自增（先进行计算 后赋值）
     x++//x=x+1//将x变量空间的内容 先取出 从常量区取出1 进行计算 再次存到x中
     想要做值交换的时候 会产生一个临时的副本空间（备份）
     ++在变量的前面 先自增后备份 ++在变量的后面 先备份后自增 并将副本空间（备份）内的值赋给别人
     x=2 y=1
例：int a = 1;
   for(int i=0;1<100;i++){
        a=a++;
   }
   a=1   //因为赋值的永远是备份空间的1
   --------------------------------------------------------------
   int m = 1；//210
   int n = 2；//321
   int sum = m++ + ++n - n-- - --m + n-- - --m；
   m=0 n= 1 sum=2
   ----------------------------------------------------------------
   赋值运算符
   = 赋值符号   将=右边的值()
   关系运算符（比较）
   > < >= <= != ==
   逻辑运算符
   & | ^ ！ &&短路与 ||   // ^逻辑异或 只要两个表达式结果不同 最终结果就是true
   位（bit）运算
   &按位与 |按位或 ^按位异或 ~ 按位取反<<按位左移位 >>按位右移位 >>>按位右移（无符号）

笔试题

&和&&的区别

&可以视为逻辑运算 也可以视为位运算 &&只能当做逻辑运算来用
如果两个都当做逻辑运算符来用 区别如下
&前后两个条件都是true 最终结果就是true
&& 短路与正常情况下&的执行结果一致
   当前面条件为flase的时候发生短路最终结果flase

最有效率的方式计算2*8的结果

   00000001                  2 << 3相当于2乘以2的3次幂
*  00001000                  00000010
-------------                00010000 == 16
00000010000==16

两个变量 int a = 1； b = 2如果将两个变量的值互换

 int a = 1;
 int b = 2;
 方式一 采用一个中间变量
 int c = a;
     a = b;
      b =c;
好处容易理解 值不会出问题 不好在于会产生一个新的存储空间
方式二
a = a+b;
b = a-b;
a = a-b;
好处省略了一个存储空间，不好在于+值可能产生越界
方法三
a = a^b;
b = a^b;
a = a^b;
学的就是高难度~

发表于 | 分类于

GIt Bash 常用命令

#change director

cd

#make director

mkdir

#print working directory 

pwd

#move 

mv

#copy 

cp

#remove

rm

其他 

echo 打印
echo 'hello' 在命令行中打印一个 hello
echo 'hello' > a.txt 创建一个纯文本文件a把hello打印进去
cat a.txt 查看a中的内容
cp a.txt b.txt 复制a 到b
ls 目录
ls ..上一级目录
mv b.txt ../b.txt 把b移动到上一级文件夹

mv a.txt c.txt 重命名
rm c.txt  删除c