就业班技术点总结

***********************day01~~day03*************************
***继承：多个类有共同的成员变量和成员方法
    ，抽取到另外一个类中（父类），
    在让多个类去继承这个父类，我们的多个类
    就可以获得父类的成员（变量和方法），
  关键字：extends
  格式：权限修饰符  class 子类 extends 父类 {}
java语言只支持单一继承，只支持一个继承
java 支持多层继承一个儿子可以有一个亲爹和一个亲爷爷
  ***子类只能继承父类的非私有成员
   就近原则：如果有局部变量就使用局部变量
     如果没有局部变量有子类的成员变量就使用子类成员变量
   子类中成员变量名字不一样，自己去找父类的成员变量
   super:可以获取父类的成员变量和成员方法，用法和this是相同的
例子：
public class Test {
  public static void main(String[] args) {
    Kid kid = new Kid();
    kid.show();
   }
  }
class Dad {
  String name = "王健林";
}
class Kid extends Dad {
  String name = "王思聪";
   public void show() {
    String name = "王五葱";
    System.out.println(super.name);// super是找到父类的变量
    System.out.println(this.name);// 找到本类的成员变量，如果本类没有，就会指到父类中的成员变量***this只能指到成员变量***
    System.out.println(name);// 就近原则，找到局部变量（方法中的变量）
   }
}


***方法重写：在子父类中，子类的方法和父累的方法完全一样，子类重写了父累的=父类的方法
，重写过后，使用子类对象调用就是子类的方法
没有重写就到调父类，重写了就调用子类重写的方法

***父类私有的成员方法不能重写*** （*子类方法权限必须大于等于父类方法权限*）
区别：位置不同：
  重载：同一个类中
  重写：存在继承关系
  重载：方法名相同，参数列表不同
  重写：抽象父类的抽象方法需要在子类中重写
  
  
  
  
方法的重写场景：
**父类不能满足子类的需要时就需要重写
注解：@Override

在有子父类的继承关系中





final关键字
*final所修饰的类不能被继承，没有子类   ***final class
*final所修饰的方法不能被子类重写   ***权限修饰符后面
*final所修饰的变量不能被修改是常量，一般常量名所有字母大写***权限修饰符后面
  *字面值常量：1,2,3，...
  *自定义常量：被final修饰的常量
  
abstract：关键字，用于修饰方法和类
*抽象方法：不同类的方法是相似的，但是具体内容不太一样，所以我们只能抽取他的声明，没有具体方法体的方法
*抽象类：有抽象方法的类必须是抽象类
注意：抽象方法的修饰符只能是public和protected  如：public abstract void ect();
  *一个子类继承了一个抽象类只有两个选择
   *1，重写抽象父类的所有抽象方法 //重写时不需要再加abstract 如：
                 @override //注解
                 public void ect(){
                  
                 }
   *2，把子类也变成abstract(抽象)类，在class前加上abstract关键字

   
   
***//static修饰的子类方法不算重写  
***接口***：接口是比抽象类更加抽象的   "类"
一个类可以实现多个接口 如： interface 接口名{}   
        class 类名 implements 接口名1，接口名2{}
接口里只有常量或者抽象方法，实现某一接口的类必须重写接口里的方法（抽象）


  


多态成员特点：
   成员变量:编译时看左边，运行时看左边
   成员方法:编译时看左边，运行时看右边
   静态方法:编译时看左边，运行时看左边
   如：
   
   
   
基本数据类型：
自动转化(小到大)： byte short char---int ---long---float---double
强制转化(大到小)
引用数据类型：
自动转换*向上转型(子到父)
强制转换*向下转型(父到子) 父类型 变量名=new 子类型();
         子类型 变量名1=(子类型)变量名；


多态优缺点；
*优点：可以提高可维护性，提高代码的可扩展性
*缺点；无法直接访问子类里面特有的成员


扩展  *instanceof*
格式：对象的变量名 instanceof 类名   
解释：boolan类型，是该类型返回true，否则返回false




**************************Day04**************************
包的特点：
  可以多层
  不同包下的文件名可以重复
  包的声明必须是第一行代码
不同包之间的互相访问：使用类的全名：格式：包名.类名
      import 包名.类名
      注意："*"(通配符)代表导入了这个包下的所有类，并没有导入子包下的类
      
修饰符:
  public :整个项目可见
  (default)什么也不写：同一个包下都可以访问
  private:只有本类中可以访问
  protected:本类及其子类(可以为不同包下)中可以访问
  
  
***成员内部类的修饰符
可以使用static修饰成员内部类，不用在创建外部类对象了。


***局部内部类的作用域和局部变量一样，出了方法就找不到了
***匿名内部类
格式：new 类/接口(){};
原理：

应用场景：作为参数进行传递

***方法里的返回值 可以是基本数据类型也可以引用数据类型***


*******************************day05******************************
获取字节码对象的方式：
对象名.getClass();
类名.class;
Class.forName("类的全名");*推荐使用*
一个类只有一个字节码对象。

***equals方法
//重写equals方法可以比较属性值等
//不重写则是Object类下的“==”，比较得是地址值
Person p1=new Person("zhangsan",15);
Person p2=new Person("zhangsan",15);
System.out.println(p1.equals(p2));//true


System类
不能被实例化（创建对象），但是不是抽象类，而是因为它的private了构造方法




System.currentTimeMillis();//当前系统时间//从1970-1-1 0:0:0 开始;
System.exit(0);//0代表正常退出，一般写0
Data类：表示特定瞬间，精确到毫秒
构造方法：Date();//当前系统时间
     Date(long date);//可以改变时间
Date常用方法
毫秒值--->Date
  设置
  返回值是void，参数long
   void setTime(long date){}
Date--->毫秒值
  返回值long，无参
  long getTime(){}
  
  
  tolocarString
  
SimpleDateFormat
格式化：formeat(Date date)
解析：parse(String str)//解析的模式必须和指定模式一样，否则会报错
例子：
public class Test {
public static void main(String[] args) throws ParseException {
  //模式
  SimpleDateFormat simpleDateFormat=new SimpleDateFormat("yyyy年MM月dd, HH时mm分ss秒");
  //当前日期
   Date date=new Date();
   //吧当前日期用模式输出
   String string=simpleDateFormat.format(date);
   System.out.println(string);//2017年12月19
   //解析
   //把simpleDateFormat的parse()方法加载模式字符串
   //并把赋值给Date类型的变量然后打印，toLocaleString()方法是以前格式时间，目前已过时，但还能用
  Date date2= simpleDateFormat.parse(string);
  System.out.println(date2.toLocaleString());//2017-12-19 0:00:00
}
}

Calendar :  Calendar s=Calendar.getInstance();//创建对象（比较特殊）
提供一些操作年月日的方法
如：
public class CalendarDemo {
public static void main(String[] args) {
  Calendar calendar=Calendar.getInstance();//创建对象
  //设置日期
//  calendar.set(Calendar.YEAR,2055);
  //添加
  calendar.add(Calendar.MARCH, -5);
  //获取当前日期
  int year=calendar.get(Calendar.YEAR);
  int march=calendar.get(Calendar.MARCH)+1;//相差一天，得加上1
  int day=calendar.get(Calendar.DAY_OF_MONTH);
  System.out.println(year+"年"+march+"月"+day+"日");
//  System.out.println(year+"年"+march+"月"+day+"日");
}
}

intVaule()//自动拆箱
new Integ(10);//自动装箱
/*
* 练习判断字符串中是否包含元音
*/
public class Test {
public static void main(String[] args) {
boolean b= chick("pAZZa");
System.out.println(b);
}
private static boolean chick(String string){
  //正则表达式用法
  return string.matches("[url=file://\\w{2}[aeiouAEIOU]\\w{1]\\w{2}[aeiouAEIOU]\\w{1[/url]}");
}
}
******************************day06****************************
集合体系结构
由于不同的数据结构，所以java 为我们提供了不同的集合
但是不同的集合他们的功能是相似的

*** 不能创建对象，要想用就只能创建子类对象如：Collenction c=new ArrayList();
Collection接口
  isEmpry()//判断是否为空
  add()//添加元素
  clear();//清空集合
  contains(Object o);//是否包含指定元素
  Object objs= ToArray();//转换为数组
  

  List接口
   ArrayList类
   LinkedList类
   
   
   Iterator迭代器
    Iterator i=arr.iterator();
    inerator:next()方法获取集合元素，注意:超过了就报错。
     **一般搭配hasNext()方法使用，hasNext()方法是判断集合是否有下一个元素，有就返回true,没有就返回false
如：
public class IteratorDemo {
  public static void main(String[] args) {
   //创建Collection集合对象
   Collection arrayList=new ArrayList();
   //向集合里添加元素
   arrayList.add("sds");
   arrayList.add("wws");
   arrayList.add("ws");
   arrayList.add("sws");
   //创建迭代器对象
   Iterator iterator=arrayList.iterator();
   //使用while循环，判断是否还有元素，
   while (true) {
    if(iterator.hasNext()){
     //输出元素
     System.out.println(iterator.next());
    }
   }
  }
}

并发异常：迭代器是依赖于集合的，当迭代器发现与集合不一样时就会发生并发异常，Iterator修改会与集合同步
**注意：用迭代器遍历是不能修改集合(集合长度如：增加元素，删除元素，清空集合)，否则会并发异常
泛型的好处：避免了类型转换问题，可以减少黄色警告，可以减少代码的书写
什么时候使用：API，当我们看到<E>是就可以使用泛型  




增强for  ***forEach
格式：for(元素类型 变量名：数组或者集合对象){
可以直接使用变量;
}
//在增强for循环中不能修改集合，否则会出现并发修改异常，因为曾强for底层是迭代，使用会出现并发修改异常

链表：增加快，查询慢。
数组：增加慢，查询快；



List:有序的
有整数索引
允许重复
List特有功能：
***注意索引，不要越界***
add(index,values)//增加时在指定索引处增加，如果指定索引处有元素，原来的元素会向后移动一个索引位置，
remove,()//吧删除指定元素返回
set(,)//将指定索引处的元素修改，并且返回修改前的元素
get(,)
List常用子类 ***一般使用ArrayList
ArrayList
  增加慢，查询快
LinkedList
  增加快，查询慢
  方法：
  void addFirst(E e)//将元素添加到索引为0的位置
  void add(E e)//将元素添加到索引为size()-1
  E getFirst()//获取索引为0的元素
  E getLast()//获取索引为size()-1的元素
  E removeFirst()//删除索引为0 的元素，并返回删除的元素
  E removeLast()//删除第一个元素，并返回删除的元素
  
  
  

就业班技术点总结

***********************day01~~day03*************************
***继承：多个类有共同的成员变量和成员方法
    ，抽取到另外一个类中（父类），
    在让多个类去继承这个父类，我们的多个类
    就可以获得父类的成员（变量和方法），
  关键字：extends
  格式：权限修饰符  class 子类 extends 父类 {}
java语言只支持单一继承，只支持一个继承
java 支持多层继承一个儿子可以有一个亲爹和一个亲爷爷
  ***子类只能继承父类的非私有成员
   就近原则：如果有局部变量就使用局部变量
     如果没有局部变量有子类的成员变量就使用子类成员变量
   子类中成员变量名字不一样，自己去找父类的成员变量
   super:可以获取父类的成员变量和成员方法，用法和this是相同的
例子：
public class Test {
  public static void main(String[] args) {
    Kid kid = new Kid();
    kid.show();
   }
  }
class Dad {
  String name = "王健林";
}
class Kid extends Dad {
  String name = "王思聪";
   public void show() {
    String name = "王五葱";
    System.out.println(super.name);// super是找到父类的变量
    System.out.println(this.name);// 找到本类的成员变量，如果本类没有，就会指到父类中的成员变量***this只能指到成员变量***
    System.out.println(name);// 就近原则，找到局部变量（方法中的变量）
   }
}


***方法重写：在子父类中，子类的方法和父累的方法完全一样，子类重写了父累的=父类的方法
，重写过后，使用子类对象调用就是子类的方法
没有重写就到调父类，重写了就调用子类重写的方法

***父类私有的成员方法不能重写*** （*子类方法权限必须大于等于父类方法权限*）
区别：位置不同：
  重载：同一个类中
  重写：存在继承关系
  重载：方法名相同，参数列表不同
  重写：抽象父类的抽象方法需要在子类中重写
  
  
  
  
方法的重写场景：
**父类不能满足子类的需要时就需要重写
注解：@Override

在有子父类的继承关系中





final关键字
*final所修饰的类不能被继承，没有子类   ***final class
*final所修饰的方法不能被子类重写   ***权限修饰符后面
*final所修饰的变量不能被修改是常量，一般常量名所有字母大写***权限修饰符后面
  *字面值常量：1,2,3，...
  *自定义常量：被final修饰的常量
  
abstract：关键字，用于修饰方法和类
*抽象方法：不同类的方法是相似的，但是具体内容不太一样，所以我们只能抽取他的声明，没有具体方法体的方法
*抽象类：有抽象方法的类必须是抽象类
注意：抽象方法的修饰符只能是public和protected  如：public abstract void ect();
  *一个子类继承了一个抽象类只有两个选择
   *1，重写抽象父类的所有抽象方法 //重写时不需要再加abstract 如：
                 @override //注解
                 public void ect(){
                  
                 }
   *2，把子类也变成abstract(抽象)类，在class前加上abstract关键字

   
   
***//static修饰的子类方法不算重写  
***接口***：接口是比抽象类更加抽象的   "类"
一个类可以实现多个接口 如： interface 接口名{}   
        class 类名 implements 接口名1，接口名2{}
接口里只有常量或者抽象方法，实现某一接口的类必须重写接口里的方法（抽象）


  


多态成员特点：
   成员变量:编译时看左边，运行时看左边
   成员方法:编译时看左边，运行时看右边
   静态方法:编译时看左边，运行时看左边
   如：
   
   
   
基本数据类型：
自动转化(小到大)： byte short char---int ---long---float---double
强制转化(大到小)
引用数据类型：
自动转换*向上转型(子到父)
强制转换*向下转型(父到子) 父类型 变量名=new 子类型();
         子类型 变量名1=(子类型)变量名；


多态优缺点；
*优点：可以提高可维护性，提高代码的可扩展性
*缺点；无法直接访问子类里面特有的成员


扩展  *instanceof*
格式：对象的变量名 instanceof 类名   
解释：boolan类型，是该类型返回true，否则返回false




**************************Day04**************************
包的特点：
  可以多层
  不同包下的文件名可以重复
  包的声明必须是第一行代码
不同包之间的互相访问：使用类的全名：格式：包名.类名
      import 包名.类名
      注意："*"(通配符)代表导入了这个包下的所有类，并没有导入子包下的类
      
修饰符:
  public :整个项目可见
  (default)什么也不写：同一个包下都可以访问
  private:只有本类中可以访问
  protected:本类及其子类(可以为不同包下)中可以访问
  
  
***成员内部类的修饰符
可以使用static修饰成员内部类，不用在创建外部类对象了。


***局部内部类的作用域和局部变量一样，出了方法就找不到了
***匿名内部类
格式：new 类/接口(){};
原理：

应用场景：作为参数进行传递

***方法里的返回值 可以是基本数据类型也可以引用数据类型***


*******************************day05******************************
获取字节码对象的方式：
对象名.getClass();
类名.class;
Class.forName("类的全名");*推荐使用*
一个类只有一个字节码对象。

***equals方法
//重写equals方法可以比较属性值等
//不重写则是Object类下的“==”，比较得是地址值
Person p1=new Person("zhangsan",15);
Person p2=new Person("zhangsan",15);
System.out.println(p1.equals(p2));//true


System类
不能被实例化（创建对象），但是不是抽象类，而是因为它的private了构造方法




System.currentTimeMillis();//当前系统时间//从1970-1-1 0:0:0 开始;
System.exit(0);//0代表正常退出，一般写0
Data类：表示特定瞬间，精确到毫秒
构造方法：Date();//当前系统时间
     Date(long date);//可以改变时间
Date常用方法
毫秒值--->Date
  设置
  返回值是void，参数long
   void setTime(long date){}
Date--->毫秒值
  返回值long，无参
  long getTime(){}
  
  
  tolocarString
  
SimpleDateFormat
格式化：formeat(Date date)
解析：parse(String str)//解析的模式必须和指定模式一样，否则会报错
例子：
public class Test {
public static void main(String[] args) throws ParseException {
  //模式
  SimpleDateFormat simpleDateFormat=new SimpleDateFormat("yyyy年MM月dd, HH时mm分ss秒");
  //当前日期
   Date date=new Date();
   //吧当前日期用模式输出
   String string=simpleDateFormat.format(date);
   System.out.println(string);//2017年12月19
   //解析
   //把simpleDateFormat的parse()方法加载模式字符串
   //并把赋值给Date类型的变量然后打印，toLocaleString()方法是以前格式时间，目前已过时，但还能用
  Date date2= simpleDateFormat.parse(string);
  System.out.println(date2.toLocaleString());//2017-12-19 0:00:00
}
}

Calendar :  Calendar s=Calendar.getInstance();//创建对象（比较特殊）
提供一些操作年月日的方法
如：
public class CalendarDemo {
public static void main(String[] args) {
  Calendar calendar=Calendar.getInstance();//创建对象
  //设置日期
//  calendar.set(Calendar.YEAR,2055);
  //添加
  calendar.add(Calendar.MARCH, -5);
  //获取当前日期
  int year=calendar.get(Calendar.YEAR);
  int march=calendar.get(Calendar.MARCH)+1;//相差一天，得加上1
  int day=calendar.get(Calendar.DAY_OF_MONTH);
  System.out.println(year+"年"+march+"月"+day+"日");
//  System.out.println(year+"年"+march+"月"+day+"日");
}
}

intVaule()//自动拆箱
new Integ(10);//自动装箱
/*
* 练习判断字符串中是否包含元音
*/
public class Test {
public static void main(String[] args) {
boolean b= chick("pAZZa");
System.out.println(b);
}
private static boolean chick(String string){
  //正则表达式用法
  return string.matches("[url=file://\\w{2}[aeiouAEIOU]\\w{1]\\w{2}[aeiouAEIOU]\\w{1[/url]}");
}
}
******************************day06****************************
集合体系结构
由于不同的数据结构，所以java 为我们提供了不同的集合
但是不同的集合他们的功能是相似的

*** 不能创建对象，要想用就只能创建子类对象如：Collenction c=new ArrayList();
Collection接口
  isEmpry()//判断是否为空
  add()//添加元素
  clear();//清空集合
  contains(Object o);//是否包含指定元素
  Object objs= ToArray();//转换为数组
  

  List接口
   ArrayList类
   LinkedList类
   
   
   Iterator迭代器
    Iterator i=arr.iterator();
    inerator:next()方法获取集合元素，注意:超过了就报错。
     **一般搭配hasNext()方法使用，hasNext()方法是判断集合是否有下一个元素，有就返回true,没有就返回false
如：
public class IteratorDemo {
  public static void main(String[] args) {
   //创建Collection集合对象
   Collection arrayList=new ArrayList();
   //向集合里添加元素
   arrayList.add("sds");
   arrayList.add("wws");
   arrayList.add("ws");
   arrayList.add("sws");
   //创建迭代器对象
   Iterator iterator=arrayList.iterator();
   //使用while循环，判断是否还有元素，
   while (true) {
    if(iterator.hasNext()){
     //输出元素
     System.out.println(iterator.next());
    }
   }
  }
}

并发异常：迭代器是依赖于集合的，当迭代器发现与集合不一样时就会发生并发异常，Iterator修改会与集合同步
**注意：用迭代器遍历是不能修改集合(集合长度如：增加元素，删除元素，清空集合)，否则会并发异常
泛型的好处：避免了类型转换问题，可以减少黄色警告，可以减少代码的书写
什么时候使用：API，当我们看到<E>是就可以使用泛型  




增强for  ***forEach
格式：for(元素类型 变量名：数组或者集合对象){
可以直接使用变量;
}
//在增强for循环中不能修改集合，否则会出现并发修改异常，因为曾强for底层是迭代，使用会出现并发修改异常

链表：增加快，查询慢。
数组：增加慢，查询快；



List:有序的
有整数索引
允许重复
List特有功能：
***注意索引，不要越界***
add(index,values)//增加时在指定索引处增加，如果指定索引处有元素，原来的元素会向后移动一个索引位置，
remove,()//吧删除指定元素返回
set(,)//将指定索引处的元素修改，并且返回修改前的元素
get(,)
List常用子类 ***一般使用ArrayList
ArrayList
  增加慢，查询快
LinkedList
  增加快，查询慢
  方法：
  void addFirst(E e)//将元素添加到索引为0的位置
  void add(E e)//将元素添加到索引为size()-1
  E getFirst()//获取索引为0的元素
  E getLast()//获取索引为size()-1的元素
  E removeFirst()//删除索引为0 的元素，并返回删除的元素
  E removeLast()//删除第一个元素，并返回删除的元素