黑马程序员-----Java基础

------- <a href="http://www.itheima.com" target="blank">android培训</a>、<a href="http://www.itheima.com" target="blank">java培训</a>、期待与您交流！ ----------

一、  Java数据类型

1.1     数据类型划分
1.2 基本数据类型
1.2.1 基本数据类型的默认值
1.3 常用的转义字符

1.4 数据类型的转换：

（1）自动类型转换和强制类型转换。

（2）任何数据类型都会向String转换。
二、 运算符、表达式与语句
2.1运算符
       （1）赋值运算符：=
       （2）一元运算符：+（正号）、-（负号）、！
       （3）算术运算符：+、-、*、/、%
（4）关系运算符：>、<、>=、<=、==、!=
（5）递增与递减运算符：++、- -
       （6）逻辑运算符：&、&&、|、||
（7）括号运算符：（）
三、 判断与循环
3.1 程序的结构
3.1.1 顺序结构
程序从上至下逐行执行，一直运行到结尾。
3.1.2 选择结构
       根据条件的成立与否，决定执行哪条语句
       （1）if…else、if…else if…else
       （2）switch  case语句
       （3）三目运算符 ？：
3.1.3 循环结构
循环就是重复执行某一段代码
（1）    while循环
（2）    do…while循环
（3）    for循环
3.2 中断语句
       （1）break跳出当前循环。
       （2）continue中断一次循环执行。
四、 数组的定义及使用
4.1 数组定义
       一组相关变量的集合。
4.2 一维数组
4.2.1 数组的动态初始化
声明方式：
      （1）数据类型  数组名[] = null
      （2）数据类型[] 数组名 = null
开辟数组空间：
      数组名 = new 数据类型[长度]
4.2.2 数组的静态初始化
       数据类型 数组名[] = {初值0，初值1，初值2……初值n}
4.3 二维数组
4.3.1 数组的动态初始化
声明方式：
      （1）数据类型  数组名[][] = null
      （2）数据类型[][] 数组名 = null
开辟数组空间：
      数组名 = new 数据类型[行的个数][列的个数]
4.3.2 数组的静态初始化
       数据类型 数组名[][] = {{第0行初值},{第1行初值}……{第n行初值} }
4.4 多维数组
       以一维数组、二维数组类推。


4.5 对象数组
4.5.1对象数组的声明
       类 对象数组名称[]=new 类[数组长度];
4.6、数组的引用传递
4.6.1接收和返回数组
一个方法可以接收一个数组，也可以返回一个数组，如果方法接收一个数组的话，则此方法对数组所做的修改将全部被保留下来。
4.6.2数组中一些方法
（1）数组排序：Java.util.Arrays.sort();    
（2）数组拷贝：System.arraycopy();
五、 方法声明及使用
5.1 方法的定义
       可重复调用的代码段。
5.1.1方法的定义格式
public static 返回值类型 方法名称(类型 参数1， 类型 参数2，…){
             方法的主体
             程序语句：
             [return 表达式]；
}
5.1.2方法的命名规范
       第一个单词首字母小写，之后单词的首字母大写。
5.2 方法的重载
       方法名字相同，但是参数类型或者个数不同，通过传递参数的类型不同或者个数不同进行调用，仅仅只是返回类型不同不能叫重载。
5.3  return语句
       （1）返回一个方法的结果。
       （2）结束一个方法。
六、面向对象设计
6.1 面向对象的三大特征
（1）封装
（2）继承
（3）多态
6.2 类与对象
       类是对某一类事物的描述，是抽象的、概念上的定义；对象是实际存在的该类事物的每个个体，因而也称实例。
6.2.1类的定义
class 类名称{
              数据类型 属性；
             ……
             public返回值类型 方法名称(类型 参数1， 类型 参数2，…){
                    程序语句：
                    [return 表达式]；
}

}
6.2.2对象的创建和使用
       （1）类名 对象名称 = null;
            对象名称 = new 类名();
       （2）类名 对象名称 = new 类名();
6.3 Java封装性与多态性
6.3.1封装的作用
       保护内容，保证某些属性可以不被外部看见。
6.3.2封装的实现
       为属性封装：private 属性类型 属性名称；
       为方法封装：private 方法返回值 方法名称(参数列表){}
6.3.3访问封装的内容
       被封装的属性如果需要被访问，则需要编写setter和getter方法，setter方法中可以加入验证，getter方法中只是把内容简单取回。
6.3.4多态性
       多态性在面向对象中是一个最重要的概要，在java中面向对象主要有以下两种主要体现：
（1）    方法的重载与覆写
（2）    对象的多态性
向上转型：父类 父类对象 = 子类实例；（自动完成）
向下转型：子类 子类对象 = （子类）父类对象；（强制）
6.4 构造方法与匿名对象
6.4.1构造方法
       class 类名称{
                     访问权限 类名称(类型1 参数1，类型2，参数2,…){
                                   程序语句；
                                   ……     //构造方法没有返回值
                     }
       注意：
（1）    构造方法的名称必须与类名称一致。
（2）    构造方法的声明处不能有任何返回值类型的声明。
（3）    不能在构造方法中使用return返回一个值。
6.4.2构造方法重载
       重载过程与普通方法一样：参数的类型或个数不同。
6.4.3匿名对象
没有名字，在java中如果只使用一次，则就可以将其定义成匿名对象。
6.5 this与super关键字
6.5.1 this关键字的作用
       （1）表示类中的属性
       （2）可以使用this调用本类的构造方法
       （3）this表示当前对象
6.5.2 使用this调用构造方法
       如果一个类中有多个构造方法，可以利用this关键字互相调用。
6.5.3 使用this表示当前对象
       当前对象：当前正在调用方法的对象

6.5.4 super关键字
       Super关键字可以从子类访问父类中的内容。
6.5.5 this与super的区别
6.6 static关键字
6.6.1 使用static声明属性
       static可以声明全局属性。
注意：
（1）    使用static声明的属性或方法可以直接由类名称调用。
（2）    使用static的方法只能访问static声明的属性或方法。
6.6.2 使用static声明方法
 使用static声明的方法可以直接由类名称调用。
6.7 final关键字
       （1）final在java中表示的意思是最终，也可称为完结器。
       （2）可以使用final声明类、属性、方法。
       （3）使用static final关键字联合声明的变量称为全局常量。
        注意：
a.使用final声明的类不能有子类；
b.使用final声明的方法不能被子类覆写；
c使用final声明的变量即成为常量，常量不可修改。
6.8  instanceof关键字
       （1）在java中可以使用instanceof关键字判断一个对象到底是哪个类的实例：
对象instanceof类 —> 返回boolean类。
       （2）在对象向下转型之前最好使用instanceof关键字进行验证。
       （3）一个类最好永远不要去继承一个已经实现好的类，而只能继承抽象类或实现接口。
6.9 继承
6.9.1 类的继承格式
       在java中使用extends关键字完成类的继承关系，操作格式：
              class 父类{}     //定义父类
              class 子类 extends 父类{}    //使用extends关键字实现继承
6.9.2 继承的限制
       在Java中只允许单继承，不能使用多重继承，但允许进行多层继承。
6.9.3 访问限制
四种访问权限：
              private、default、public、protected
       大小关系：private<default<protected<public
注意：
子类是不能直接访问父类中的私有成员的，但子类可以调用父类中的非私有方法，但是不能直接调用父类中的私有成员。
6.10方法的重载与覆写
6.10.1 方法覆写
       方法覆写就是指子类定义了父类中同名的方法，但是在方法覆写时必须考虑到权限。
6.10.2 方法重载
       就是在类中可以创建多个方法，它们具有相同的名字，但具有不同的参数和不同的定义。调用方法时通过传递给它们的不同参数个数和参数类型来决定具体使用哪个方法, 这就是多态性。重载的时候，方法名要一样，但是参数类型和个数不一样，返回值类型可以相同也可以不相同。重载（Overloading）是一个类中多态性的一种表现。
6.10.3 方法重载与覆写的区别
       方法的重写Overriding和重载Overloading是Java多态性的不同表现。重写Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Overriding)。子类的对象使用这个方法时。
如果子类的方法名和参数类型和个数都和父类相同，那么子类的返回值类型必须和父类的相同；如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载。Overloaded的方法是可以改变返回值的类型。也就是说，重载的返回值类型可以相同也可以不同。
6.11抽象类
6.11.1概念：
       包含一个抽象方法的类就为抽象类。
       抽象方法：只声明而未实现的方法称为抽象方法，抽象方法必须使用abstract关键字声明。
6.11.2定义格式
Astract class 抽象类名称{
属性；
访问权限 返回值类型 方法名称(参数){
              [return返回值]；
}
访问权限abstract返回值类型 方法名称(参数)；
//在抽象方法中是没有方法体的
}
6.11.3用法
       （1）抽象类使用的时候一定要有子类，子类仍然使用extends关键字继承一个抽象类，同样会存在但继承的关系。一个子类不能同时继承多个抽象类。
       （2）抽象类中绝对不能使用final关键字声明。
       （3）抽象类中允许有构造方法，而且完全符合子类对象的实例化过程。
6.12接口
6.12.1概念
       接口是java中最重要的概念，接口可以理解为一种特殊的类，里面全部是由全局常量和公共的抽象方法所组成。
6.12.2定义格式
interface接口名称{
              全局常量；
              抽象方法；
}
6.12.3实现接口
       与抽象类一样，接口要使用也必须通过子类，子类通过implements关键字实现接口。
       实现格式：
       Class 子类 implements 接口A, 接口B，…{
}
6.12.4继承抽象类实现接口
       格式如下：
       Class 子类 extends 抽象类 implements 接口A, 接口B，…{}
6.12.5用法
       （1）接口是一个特殊的类，只包含全局常量和抽象方法，接口中的抽象方法可以不加入abstract而抽象类中的抽象方法必须有abstract关键字声明。
       （2）一个类只能继承一个父类，但是可以同时实现多个接口。
       （3）一个接口可以同时继承多个接口，以实现接口的多继承。
       （4）接口和抽象一样，都必须依靠子类。
       （5）一个抽象可以实现多个接口，但是一个接口不能继承一个抽象类。
6.12.6抽象类与接口的关系
6.13 java异常处理
6.13.1概念
       异常是导致程序中断运行的一种指令流，异常是程序运行过程出现的错误，在Java中用类来描述，用对象来表示具体的异常。
       在异常中最大的类是Throwable，分为两个子类：Exception、Error
              Exception：是程序可以自己处理异常。
              Error：表示JVM错误，一般程序无法处理。
6.13.2 try…catch异常处理
try语句块，表示要尝试运行代码，try语句块中代码受异常监控，其中代码发生异常时，会抛出异常对象。 
catch语句块会捕获try代码块中发生的异常并在其代码块中做异常处理，catch语句带一个Throwable类型的参数，表示可捕获异常类型。当try中出现异常时，catch会捕获到发生的异常，并和自己的异常类型匹配，若匹配，则执行catch块中代码，并将catch块参数指向所抛的异常对象。catch语句可以有多个，用来匹配多个中的一个异常，一旦匹配上后，就不再尝试匹配别的catch块了。
通过异常对象可以获取异常发生时完整的JVM堆栈信息，以及异常信息和异常发生的原因等。
finally语句块是紧跟catch语句后的语句块，这个语句块总是会在方法返回前执行，而不管是否try语句块是否发生异常。并且这个语句块总是在方法返回前执行。
6.13.2常见异常类
七、Java常用类
7.1 String类
7.1.1 实例化String对象
       （1）直接赋值
       （2）通过关键字new
7.1.2  String内容比较
       两种比较方式：
（1）    使用“==”完成，比较的是地址值。
（2）    使用“equals”方法完成，比较的是具体内容。
7.1.3 常用方法
       （1）将字符串变为字符数组：toCharArray()
       （2）字符数组变为字符串：Sring()
       （3）字符串中取出指定字符：charAt()
       （4）取得字符串长度：length()
       （5）查找指定字符串是否存在：indexOf()
       （6）去掉空格：trim()
（7）字符截取：subString()
（8）拆分字符串：split()
（9）大小写转换：toUppercase()、toLowercase()
（10）判断是否以指定的字符串开头或结尾：startWith()、endsWith()
（11）不区分大小写的比较：equalsIgnorecase()
（12）字符串替换：replaceAll()
7.2 StringBuffer类
7.2.1定义
       StringBuffer是使用缓冲区的，本身也是操作字符串的，但是与String类不同，String类的内容一旦声明则不可以改变，改变的是其内存地址的指向，而StringBuffer中的内容是可以改变的。
7.2.2常用方法
（1）连接字符串操作：append()
（2）在任意位置处为StringBuffer添加内容：insert()
（3）字符串反转操作：reverse()
（4）替换指定范围的内容：replace()
（5）字符串截取：subString()
（6）字符串删除：delete()
（7）查找指定的内容是否存在：indexOf()
7.3日期操作类
7.3.1 Date类
       直接输出其实例化对象即可
7.3.2 Calendar类
       可以将日期精确到毫秒，按照自己的需要的格式显示时间。
calendar.get(Calendar.YEAR));
calendar.get(Calendar.MONTH));
calendar.get(Calendar.DATE));
7.3.3 DateFormat类
       是一个日期的格式化类，专门格式化日期的操作。
（1）    得到日期的DateFormat对象：DateFormate.getDateInstance()
（2）    得到日期时间的DateFormat对象：DateFormate.getDateTimeInstance()
7.3.4 SimpleDateFormate类
       是DateFormat类的子类，一般情况下来讲DateFormat类很少会直接使用，而都是使用SimpleDateFormat类完成。
7.4 File类
表示与文件本身有关的类。
7.4.1常用方法
       （1）创建文件：createNewFile()
       （2）删除制定文件：delete()
       （3）判断文件是否存在：exists()
       （4）创建文件夹:mkdir()
       （5）列出指定目录的全部文件：list()、listFiles()
       （6）判断一个给定的路径是否是目录：isDirectory()
7.5 List接口
       List接口可以存放任意的数据，而且在List接口中内容是允许重复的，扩充了Collection接口的操作。
7.5.1 ArrayList
       是List子类，为List接口实例化。
      定义：
List<泛型>  名字=new ArrayList<泛型>();
方法：
（1）    添加：add()
（2）    删除：remove()
（3）    得到值：get()
（4）    判断是否为空：isEmpty()
（5）    截取部分集合：subList()
（6）    查找指定的对象是否存在：indexOf()
（7）    查找是否存在：contains()
7.6 Set接口
7.6.1 定义
       Set接口也是Collection接口的子类，但与Collection或List接口不同，Set接口中不能加入重复的元素。
Set<泛型>  名字=new HashSet <泛型>();
Set<泛型>  名字=new TreeSet <泛型>();
7.6.2 常用子类
（1）散列存放：HashSet
（2）有序存放：TreeSet
7.7 Iterator接口
7.7.1 简介
       在使用集合输出的时候必修形成以下的思路：‘只要是碰到了集合输出的操作，就一定使用Iterator接口’。
       对于Iterartor而言，因为其本身是一个接口，所以要想实例化则必须依靠Collection接口完成。
定义：
List<String>  all=new ArrayList<String>();
Iterator<String>  iter=all.iterator();
       Iterator接口的功能是从前向后输出，属于单向的输出，主要功能就是完成迭代输出操作的。
7.7.2 方法
       （1）判断是否有内容：hasNext()
       （2）输出内容：next()
       （3）删除当前对象：remove()
7.8 Map接口
       在Map中保存的是一对对象，对象的形式是以：key—>value的形式保存的。
7.8.1 Map接口中常用的子类
       （1）HashMap：无序存放，key不允许重复
       （2）Hashtable：无序存放，key不允许重复
       （3）TreeMap:可以排序的Map集合，按集合中的key排序，key不允许重复
       （4）WeakHashMap：弱引用的Map集合，当集合中的某些内容不再使用时，可以清掉无用的数据，可以使用gc进行会收
       （5）IdentityHashMap：key可以重复的Map集合
7.8.2 Map方法声明
       Map<String,String> map=new HashMap<String,String>();
7.8.2 Map基本方法
       （1）增加内容：put()
       （2）根据key取出值：get()
       （3）判断指定的key或value是否存在：containsKey()、containsValue()
       （4）得到全部的key：keySet()
       （5）得到全部的value：values()
7.8.3 HashMap与Hashtable的区别
7.8.4 TreeMap
       使用TreeMap可以方便的完成排序的操作。
7.9 集合工具类：Collections
7.9.1 常用方法
       （1）空集合的操作：emptyList()、emptySet()
       （2）输入数据：addAll()
       （3）二分检索：binarySearch()
       （4）替换内容：repalceAll()
       （5）排序：sort()
      （6）交换指定内容：swap()
7.10 枚举
       所谓枚举，就是规定好了指定的取值范围，所有的内容只能从指定的范围中取得。
7.10.1 定义一个枚举类型
       [public] enum 枚举类型名称{
       枚举对象1，枚举对象2，… ，枚举对象n；
}