黑马程序员技术交流社区

标题: 【石家庄校区】就业班第一阶段笔记 [打印本页]

---

作者: 李迪13524    时间: 2017-12-21 17:30
标题: 【石家庄校区】就业班第一阶段笔记

就业班第一阶段笔记

Day01(2017-12-13)面向对象
第一章、知识回顾   
1.1数据类型的回顾
基本数据类型（4类8种）
整数（byte short int long）
浮点数（float double）
字符（char）
布尔（boolean）
引用数据类型（数组，类，接口）
Student s=new Student();
基本数据类型的转换
自动类型的转换
Byte short char –int –long—float—double(由小到大)
强制类型转换（有可能损失精度）
一般由大到小    int a=300;  byte b=(byte)a;  有可能损失精度
运算符
算数运算符  （++  --）
++i先自增，然后使用i自增的值作为++i表达式的值，再进行运算
i++先使用i的值作为i++表达式的值进行运算，再自增
比较运算符   （比较运算符的结果都是boolean类型的）
赋值运算符    （隐含了强制类型的转换）
逻辑运算符    （连接boolean类型的表达式）
1.2、方法的回顾
案例：定义一个方法求2个数的和，并在方法中调用
方法：类中的一段具有特定功能的程序，提高了代码的复用性和可维护性。
定义格式：public  static 返回值类型（没有就返回void） 方法名（参数类型 参


数名，参数类型 参数名）{
//形参
方法体；
}
调用方法：
                        有明确返回值类型：
                                                赋值调用，将方法的返回值赋


值给一个变量
                                                输出调用，使用输出语句直接


输出方法的返回值
                                                直接调用，没法获取方法的返


回值
                        没有明确返回值类型：
                                                        直接调用
方法重载：在一个类中有多个重名的方法，这些方法参数不同，和返回值无关
形参：方法声明的变量，只能是变量、，接收方法调用时传递进来的数据
实参：调用方法时传递的数据，可以是常量也可以是变量
public class MethoDemo {
        public static void main(String[] args) {
                //赋值调用
                //int sum = sum(10,20);//实参
                //System.out.println(sum);
               
                //输出调用
                inta = 10;
                intb = 20;
                System.out.println(sum(a,b));
        }
        
        public static intsum(inta,intb) {
        /*        //使用变量接收求和结果并返回
                int sum = a + b;
                return sum;*/
               
                //直接返回求和结果
                returna + b;
        }
1.3、数组的回顾
案例：定义一个元素为int的数组，遍历数组并求和
数组：用于存储多个元素的一种容器
数组的特点：
                                元素类型必须一致
                                元素有整数索引
                                一旦定义好长度则无法改变
                                可以存储基本数据类型
                                也可以存储引用数据类型
定义格式：
动态初始化
                元素类型 [] 数组名=new 元素类型[10]；
静态初始化
                元素类型[]数组名={元素1，元素2，元素3}；
                元素类型[]数组名=new元素类型[]{元素1，元素2，元素3}；
1.4、标准类定义和使用回顾
成员变量  姓名 性别 年龄private成员变量私有
第二章、static静态关键字


2.1、静态的概述
Static是一个关键字，用来修饰成员方法，成员变量，使其被该类的所有对象共享
如何调用static修饰的变量个方法
类名.静态成员属性  system.out
类名.静态成员方法 Arrays.toString(arr)
*2.2、静态的特点
①静态成员被所有对象共享
②静态成员可以直接使用类名调用
③静态成员的加载优先于对象
       静态资源在创建类时加载并初始化（在方法区中）
                非静态资源在创建对象时才加载并初始化（在堆内存中）
④静态成员的生命周期
       随着类的加载而创建，直到程序结束
2.3静态的内存图解
①静态成员在内存中的位置（方法区中的类的字节码区域中的静态区域中）
②静态成员的加载时机  （随着所在类的加载而加载）
③静态成员和非静态成员的区别
生命周期不同
静态成员：随着类的加载而加载，随着程序的结束而销毁
非静态成员：随着对象的创建而创建，随着对象的销毁而销毁
所以，静态成员的生命周期优先于非静态成员创建，晚于非静态成员的销毁
内存中的定义位置不同；
静态成员：在方法区中类字节码区域的静态区中
非静态成员：堆内存中
参数化时机不同
静态成员：类加载时初始化
非静态成员：对象创建时初始化
*2.4静态的注意事项
①静态成员只能直接访问静态成员
原因: 因为静态方法随着类的加载而加载, 而非静态方法随着对象的创建而加载, 当


静态方法加载时, 并不一定创建了对象, 所以不一定有对象可以调用非静态方法, 为


了避免这种不安全的访问, 所以静态方法中只能调用静态资源
②非静态成员既可以访问非静态成员也可以直接访问静态成员
原因: 非静态方法随着对象的创建而创建, 对象创建的前提是类已经加载, 类在加载


时已经加载了静态资源, 所以当对象调用非静态方法时, 静态资源一定存在, 这种访


问是安全的
③静态方法不能使用this
This含义：表示当前类的对象的引用
This作用：区分成员变量和局部变量重名的问题
因为this引用当前类的对象, 而静态方法在类加载时已经加载, 此时没有对象可以引


用
2.5、静态的优缺点
优点：为共享数据提供了同一个存储空间，节省内存空间
                可以直接类名调用，不用创建对象
缺点：访问有局限，只能访问静态
静态的应用场景：
作为该类所有对象的共享数据
工具类，工具类一般只用于调用其中的方法进行逻辑处理，没必要创建多个对象，所


以静态类名直接调用方法即可
2.6、静态的应用(①Math类的使用②自定义工具类)
2.6.1、Math类的使用
Math:包含了一些基本的数学运算方法
Math类静态成员属性：
①        static double pl:接近圆周率的一个数字
System.out.println(Math.PI);
静态成员方法：
①   Static double abs(double a):返回绝对值
System.out.println(Math.abs(-10));
②  St7atic double ceil(double a):天花板向上取整
System.out.println(Math.floor(1.6));
③  Static double floor (double a):地板向下取整
System.out.println(Math.floor(1.2))
④   Static double round(double a):四舍五入
System.out.println(Math.round(1.2));
⑤  Static double max(double a, double b):最大值
System.out.println(Math.max(3, 4));
⑥  Static double pow(double a, double b):返回第一个参数的第二个参数次幂
System.out.println(Math.pow(3, 2));
        ⑦  Static double abs(double a):返回一个随机数，大于零并且小于1
System.out.println(Math.random());
2.6.2、自定义工具类
        利用statc9可以直接类名调用方法的特点，定义类作为工具类，处理常用操


作
步骤：定义一个类
        Private修饰构造方法：因为没必要使用对象
        使用static修饰工具方法
如何避免一个类创建对象？
        将构造方法使用private修饰，让外界无法访问
2.7、类变量与实例变量辨析
⑴类变量：其实就是静态变量
定义的位置是在类中方法外
所在内存区域：方法区
生命周期：随着类的加载而加载
特点：无论创建多少对象，类变量仅在方法区中并且只有一份
⑵实例变量：其实就是非静态变量
定义位置：定义在类中方法外
所在内存区域：堆
生命周期：随着对象的创建而加载
特点：每创建一个对象，堆中的对象中就有一份实例变量
3、代码块（使用{}括起来的代码成为代码块）
3.1局部代码块
定义位置：方法中
执行时机：执行到方法中的局部代码块时
作用：控制局部变量的生命周期（作用域）
3.2、构造代码块
定义位置：类中，方法外
执行时机：创建一个对象时，**在构造方法之前执行**，无论使用无参还是有参构造
方法
作用：为所有构造方法都执行同一种操作，减少构造方法中编写重复代码
3.3、静态代码块
定义位置：类中，方法外，static修饰
执行时机：加载类时执行，只执行一次
作用：在加载类时进行一些初始化操作，并且只需要执行一次
3.4同步代码块（多线程讲解）
3.5面试题（代码块的先后执行顺序题）
Mian（）方法是程序的入口，要执行main()方法，先要加载main()方法所在的类，所


以执行blockTest静态代码块执行
接下来执行main()方法，在创建coder对象时时第一次使用coder类，所以先要加载


coder类，此时执行coder静态代码块
当加载coder对象时，先执行coder静态代码块，然后执行构造方法
Day02(2017-12-14)(面向对象)
*第一章继承
1.1、继承的概述
在现实生活中，继承一般指的是子女继承父辈的财产。在程序中，继承描述的是事物


之间的所属关系，通过继承可以使多种事物之间形成一种关系体系。
从已有类派生出新的类
                        已有类称为父类（基类），新类成称为子类（派生类）
                        子类对父类的关系就是继承
1.2、继承的格式和使用
继承关键字extends
格式：class 子类 extends 父类{  }
使用：多个类有共同的成员变量和成员方法，抽取到另外一个类中（父类），在让多


个类去继承中这个父类，我们的多个类就可以获取到父类中的成员了。
1.3、继承的特点
①在Java中，类只支持单继承，不允许多继承，也就是一个类只能有一个直接父类继


承。（一个儿子只能有一个亲爹）
②        多个类可以继承一个父类，（一个）
Class A{}
Class B extends A{}
Class C extends A{}  //类B和类C都可以继承类A
③        多层继承是可以的，即一个类的父类可以再去继承另外的父类，
Class A{}
Class B extends A{}    //类B继承类A,类B是类A的子类
Class c extends B{}    //类C继承类B, 类C是类B的子类，同时也是类A的子类
④子类和父类是相对概念，也就是说一个类是某一个类父类的同时，也可以是另外一


个类的子类。
Java中所有类都直接或间接的继承自object类
1.4、继承中成员变量的特点
子类只能获取父类非私有成员
                        子父类中成员变量的名字不一样直接获取父类的成员变量
                        子父类中成员变量名字是一样的获取的是子类的成员变量
就进原则：谁离进就用谁
                如果有局部变量就使用局部变量
                如果没有局部变量，有子类的成员变量就使用子类的成员变量
                如果没有局部变量和子类的成员变量，有父类的成员变量就使用父


类的成员变量
Super:可以获取父类的成员变量和成员方法，用法和this相似
1.5、继承中成员方法的特点和方法的重写
继承中成员方法的特点
                        子类中没有这个方法，调用父类的
                        子类中重写了这个方法，调用子类的
方法的重写：在子父类中，子类的方法和父类的方法完全一样，子类重写了父类的方


法（覆盖），当子类重写了父类的方法之后，使用子类对象调用的就是子类的方法
方法重载：在一个类中，有多个重名的方法，但是其参数不一样（参数个数，参数的


类型，参数的顺序），和返回值无关
重载（override）和重写（overload）的区别：




1.6、方法重写的应用场景和注意事项
应用场景：当父类的方法不能完全满足子类使用，这个时候子类可以重写父类的方法
在重写方法中使用‘super.方法名（）’调用父类方法，即可以保留父类方法功能，


也能实现自身特有功能
@overrider注解
注意事项：不可以重写父类私有的成员方法，压根就看不到父类的私有成员
                         子类重写父类方法，权限必须大于父类方法的权限
1.7、继承中构造方法的执行顺序
A：super(实参列表)语句：在子类的构造方法中使用，用来调用父类中的构造方法（


具体哪一个由传递的参数决定），并且只能在构造方法第一行使用
B：this（实参列表）语句：在类的构造方法中使用，用来调用本类中的其他构造方


法（具体哪一个由传递的参数决定），并且只能在构造方法的第一行使用
执行顺序：
在子父类中，创建子类对象，调用子类的构造方法
在子类的构造方法的第一行代码如果没有调用父类的构造或者调用子类的其他构造，


则默认调用父类无参
为什么要调用父类构造？
因为要给父类的成员变量初始化
肯定会先把父类的构造执行完毕，在去执行子类构造中的其他代码
1.8、this与super的区别
This：当前对象的引用
                        调用子类的成员方法
                        调用子类的成员变量
                        在子类的构造方法第一行调用子类其他构造方法
Super:子类对象的父类引用
                调用父类的成员变量
                调用父类的成员方法
                在子类的构造方法第一行调用父类的构造方法
1.9、继承的优缺点
优点：提高了代码的复用性
                提高了代码的可维护性
缺点：类的耦合性
开发的原则：高内聚低耦合
内聚：就是自己完成某件事情的能力
耦合：类与类的关系
第二章匿名对象和final
2.1、匿名对象定义和使用
匿名对象： 没有名字的对象
匿名对象的应用场景:当方法值调一次的时候可以直接使用匿名对象
可以当作参数进行传递，但是无法再传参之前做其他的事情
注意：匿名对象可以调用成员变量并赋值，但是赋值并没有意义
2.2、final关键字
修饰符，可以修饰类，方法，变量
作用：修饰类：不能被继承
     修饰方法：不能被重写
修饰变量：是不可以修改的 是常量
常量：字面值常量：1,2,3
        自定义常量：被final所修饰的成员变量，一旦初始化则不可改变


注意：自定义常量必须初始化，可以选择显示初始化或者构造初始化
*第三章、抽象类
3.1、抽象类概述
Abstract:关键字，用于修饰方法和类
抽象方法：不同类的方法时相似，但是具体内容又不太一样，所以我们只能抽取他的


声明，没有具体的方法体，没有具体方法体的方法就是抽象方法
抽象类：有抽象方法的类必须是抽象类
注意：一个类继承了抽象类需要重写他所有的抽象方法，否则这个类就的是抽象类


3.2、抽象类的特点
抽象类的特点
        抽象类和抽象方法必须被abstract修饰
        抽象方法只能定义在抽象类中
        抽象类中可以有非抽象的方法，并且也可以只有非抽象的方法
        抽象类不能创建对象（即不能实例化，不能new）
                        因为抽象类中有抽象方法不应该被对象调用
                        但可以定义构造方法，在子类创建对象时调用默认的


super来执行抽象类的一些初始化操作
        抽象类和类之间也可以存在继承关系
        一个类继承了抽象类只有2 种操作：
                        重写抽象方法
                        自身该变为抽象类
3.3、抽象类成员的特点
成员变量：可以有成员变量，也可以有常量
成员方法：可以有抽象方法，也可以有非抽象方法
构造方法：可以有构造方法，用于子类通过调用super（）；使抽象类的成员进行初


始化
3.4、抽象类案例
3.4.1老师案例
3.4.2员工案例
3.4.3技师案例
3.5抽象类的细节
①抽象关键字abstract不可以和哪些关键字共存？private和final
Private：
        私有的方法子类时无法继承到的，也不存在覆盖，而abstract和private一


起使用修饰方法，abstract既要子类去实现这个方法，而private修饰子类根本无法


的到父类这个方法，互相矛盾。
Final:
抽象类不能和final共存，因为抽象类自身无法创建对象，我们需要通过子类创建对


象，一旦抽象使用final关键字，那么抽象类就没有子类
        抽象方法不能和final共存，因为抽象方法后期需要被子类重写，一旦加


final无法重写
Static：
         抽象方法不能和static关键字共存，因为一旦加static我就可以通过类名直


接访问抽象方法，由于抽象方法没有方法体，没有任何意义，也不允许这样做
②抽象类中是否有构造函数？
有， 抽象类的构造函数，是由子类的super语句来调用，用于给抽象类中的成员初始


化
④        抽象类中可不可以没有抽象方法？
可以，抽象类的存在到底有什么意义呢？不让该类创建对象，方法可以直接让子类去


使用。
3.6抽象类的思想（起到规范的作用）


Day03(2017-12-16)(面向对象)
第一章接口
+1.1接口的概述（interface）
概念：接口是个比抽象类还抽象的类，接口里所有的方法全是抽象方法，接口和类的


关系是实现
类和接口的关系：
                ①类实现接口
②实现接口的类称为***接口的实现类
作用：①扩展功能
      ②弥补Java单继承的局限性，抽象类只能单继承，而接口可以多实现
一个类如何实现接口：
                Implements关键字
                格式：权限修饰符 interface 接口名{}
1.2接口的格式和使用
权限修饰符 Interface  接口名{  


}
1.3接口中成员的特点
接口的成员变量
                必须都是常量（自定义常量）
                默认是public static final 修饰的，也可以不写
接口的构造方法：
                不能定义构造方法，也不能创建对象
接口的成员方法：
                必须都是抽象方法
                不能是static的
                默认是public abstract修饰，也可以不写
                        如果写也是public abstract修饰，因为接口必须通过实


现类来实现抽象方法，如果方法权限不足以调用，则无法打成目的
注意：
类与接口的关系是实现关系，一个类实现一个接口必须实现它所有的方法
1.4接口和类的关系
类与类之间：继承关系，（单继承，多层继承）一个类只能直接继承一个父类，但是


支持多重继承
类与接口之间：只有实现关系，一个类可以实现对个接口
接口与接口之间：只有继承关系（多继承，多继承），一个接口可以继承多个接口
一个类，即可以继承一个父类，有可以实现多个接口（继承在前，实现在后）
1.5接口的思想
Java中应用的接口（ List<E>   collection<E> ）
为什么要设计成接口？
                提供规则，规定实现类必须实现接口中要求的方法，具体如何实现


由实现类定义
1.6接口的优点
⑴类与接口的关系，实现关系，而且是多实现，一个类可以实现多个接口，类与类之


间是继承关系，Java中的继承是单一继承，一个类只能有一个父类，打破了继承的局


限性
⑵对外提供规则（USB接口）
⑶降低了程序的耦合性（可以实现模块化开发，定义好规则,每一个实现自己的模块


，提高了开发的效率）
1.7接口和抽象类的区别
相同点：  接口和抽象类都是抽取出共性的内容
不同点：
①        与类的关系不同
类和接口是实现关系：多实现
类和抽象类时继承关系：单继承，多层继承
②         成员变量定义不同
接口只能有静态常量 public static final
抽象类可以有成员变量，也可以有常量
③        成员方法定义不同
接口只能有抽象方法 public abstract
抽象类可以有抽象方法，也可以没有抽象方法（避免创建对象），也可以也非抽象方


法
④        构造方法定义不同
接口不能有构造方法，也不能创建对象
抽象类可以有构造方法， 用于初始化成员，但不能创建对象
什么时候用抽象类，什么时候用接口？
                当需要定义的类可以作为子类的父亲，并且里面有抽象的方法时，


则定义为抽象类（如动物和猫，猫属于动物，动物中包含猫）
                当需要定义的类不足一作为子类的父亲，而只是用于扩展功能时，


则定义为接口
（如爬树和猫，猫不属于爬树，猫只是具有爬树的功能）
1.8运动员案例
第二章多态
2.1多态概述（一个事物可以具有多种变现形态）
多态的前提：
        子父类的继承关系
        方法的重写
        父类引用指向子类对象 Animal cat=new Cat();
动态绑定：
                对象调用的成员方法，是根据程序运行时的具体的类型确定的
2.2多态的定义与使用格式8
多态的定义格式：就是父类的引用变量指向子类对象
        父类类型  变量名=new 子类类型（）；
        变量名.方法名（）；


⑴        普通类多态定义的格式
                父类变量名= new 子类（）；
                Class fu{}
                Class zi extends Fu{}
                //类的多态使用
                Fu f=new zi();
⑵        抽象类多态定义的格式
        抽象类变量名 =new 抽象类子类（）；
                Abstract  class Fu{
               Public abstract void  method();}
class  zi extends Fu{
public void method(){
system.out.println(“重写父类抽象方法”)}}
                //类的多态使用
           FU fu=new zi();
⑶   接口多态定义的格式
接口变量名=new 接口实现类（）；
2.3、多态成员的特点
类型以哪边为准？ Dad x=new Kid();
成员变量：编译看左边，运行看左边
静态方法：编译看左边，运行看左边
成员方法：便于看左边，运行看右边
2.4多态中的向上转型和向下转型
转型：即转换类型
向上转型：
                子类型转换为父类型（自动转换）
向下转换：
                父类型转换为子类型（强制转换）
类型转换
        基本数据类型
                自动转换：从小到大 byte,short,char—int—long—float--


double
                强制转换：从大到小  double d=1000.0;int i=(int)d;
    引用数据类型
自动转换：向上转型：Father fa=new Son();
强制转换：向下转型：Son s=(Son)fa;
2.5多态的优缺点
优点：可以提高代码的可维护性（多态的前提保证），提高代码的可扩展性
缺点：无法直接访问子类特有的成员
2.6扩展instanceof语句
作用：判断一个对象是否是某个类的对象，如果是则返回true，如果不是则返回


false
Day04(2017-12-17)(面向对象)
第一章        包和权限修饰符
1.1包的概述(包其实就是一个文件夹)
包是用来管理类的，避免重命名的冲突
包的特点：
                可以有多层
                不同包下文件名可以重复
                包的声明必须是第一行代码
1.2包的声明格式
Package 包名.包名.包名…;
包名采用全部小写字母
注意：声明包的语句，必须写在程序有效代码的第一行
1.3包之间互相访问
如何导入包：
使用类的全名（包名.类名）
使用关键字import将类导入
导入语句的位置：（包下，类的上边）
注意：代表的是通配符，代表导入了这个包下所有的类，并没有导入子包下的类
访问规则：相同包下的类：直接访问
                不同包下的类：⑴导入包之后直接使用类 ⑵使用类的全名
1.4、权限修饰符
Private:当前类
Default:当前类，相同包下不同的类
Protected :同一个包中，或者子类中
Public : 当前类，相同包下不同的类 ，整个项目     
1.5、修饰符总结
以后我们使用public来修饰，一个Java文件中只能有一个类
                如果一个文件中有多个类，类名和文件名一样的类名，必须用


public修饰，其他的类不能使用public 来修饰
以后所有的成员变量都使用private修饰
以后所有的方法都使用public来修饰
以后所有的构造方法public来修饰
                如果你不想让创建对象，使用private修饰
第二章、内部类
2.1、内部类概述；
成员内部类：类中，方法外
非静态成员内部类     静态成员内部类
        局部内部类：方法中
        匿名内部类：方法中或方法参数中，且必须创建对象
内部类的共同特点：
                        虽然编写时在同一个Java文件中，但编译后都是独立


的.class字节码文件
                        内部类编译后字节码文件名是  外部类名$内部类名
2.2、成员内部类（非静态成员内部类）
①非静态成员内部类的定义位置：
                与成员属性和成员方法平级，一般定义在底部
②创建非静态成员内部类的对象：
格式：外部类名.内部类名 对象名=new 外部类名（）.new 内部类名（）；
③为什么要先创建外部类对象？
因为非静态成员内部类属于成员，非静态成员是跟随对象的创建而创建的，所以必须


先创建外部类对象，才能加载非静态成员内部类的定义，才能访问到非静态成员内部


类的构造方法，才能创建非静态成员内部类对象
所以相当于:
先创建外部类对象: Outer outer = new Outer();
然后使用外部类对象创建内部类对象: Outer.Inner inner = outer.new Inner();
只不过我们创建外部类对象使用了匿名内部类的方式: Outer.Inner inner = new


Outer().new Inner();
2.3成员内部类的修饰符：（静态内部类）
成员内部类也可以使用修饰符修饰
权限修饰符
Public 、Protected和默认都可以
Private：只能在该内部所在的外部类中访问，在其他类中无法访问
    与私有成员变量一样，因为内部类时外部类的成员，所以外部类中可以访问自己


的内部类，而其他类中权限不够，不能访问该内部类
Static：静态成员内部类
Abstract:可以，抽象类
Final：可以，不让继承
创建静态成员内部类对象：
格式：外部类名.内部类名 对象名=new 外部类名.内部类名（）；
为什么不用先创建外部类对象？
因为static修饰的是静态，随着类的加载而加载，外部类加载后内部类也就加载了，


所以可以直接用内部类的全名形式调用构造方法
2.3、局部内部类（定义在方法中）
定义位置：
和局部变量同级，定义在方法中，出了方法无法使用局部内部类
局部内部类的使用:
调用外部类的方法，执行外部类方法过程中会定义内部类，并创建内部类对象，调用


内部类方法
外部类方法执行完毕之后，局部内部类对象，局部内部类的定义        
*2.4、匿名内部类
定义位置：
定义在方法或方法的参数中，且必须创建对象
定义格式：
                定义类和创建对象行为是一起的
匿名内部类的格式：
New 类 或接口名（）{
可能需要重写方法
}；
注意：
new出来的实际上是类或接口的子类对象
                如果创建了继承普通类的子类对象，可以自主选择是否重写父类方


法
                如果创建了实现接口或抽象类的子类对象，则必须重写父类所有的


抽象方法
匿名内部类的使用方式：
方式1：创建并定义匿名内部类
使用变量接收创建的对象
使用对象变量调用方法
方式2 ：创建并定义匿名内部类
直接.链式调用匿名内部类对象的方法
（        可以把匿名内部类看成是一个没有名字的局部内部类
定义在方法当中
必须在定义匿名内部类的时候创建他的对象）
2.5、匿名内部类的应用场景
应用场景：作为参数进行传递
只用一次的抽象类或接口的子类，免去专门定义一个类
2.6、修饰符可以修饰的元素
修饰符        类        内部类        局部内部类        成员变量        成员方法        构


造方法
Public        Y        Y        不是        Y        Y        Y
默认        Y        Y        Y        Y        Y        Y
Protected        不是        Y        不是        Y        Y        Y
Private        不是        Y        不是        Y        Y        Y
Abstract        Y        Y        Y        不是        Y        不是
Static        不是        Y        不是        Y        Y        不是
Final        Y        Y        Y        Y        Y        不是
2.7内部类和外部类的相互访问规则：
⑴内部类访问外部类成员：
①非静态内部类
可以访问外部类的非静态成员变量
可以访问外部类的静态成员变量
②静态内部类
不能访问外部类的非静态成员变量
可以访问外部类的静态成员变量
⑵外部类访问内部类成员
①        非静态内部类
外部类不能直接访问非静态内部类成员
外部类可以通过非静态内部类对象访问非静态内部类的非静态成员
外部类可以通过非静态内部类类名访问非静态内部类的静态成员
②静态内部类
                  外部类不能直接访问静态内部类成员
                  可以通过静态内部类对象访问静态内部类的非静态成员
可以通过静态内部类类名访问静态内部类的静态成员
⑶        匿名内部类和直接定义子类实现接口或继承抽象类，应该用哪种方式？
分情况：
如果对这个接口或抽象类，只有一种实现方式，就直接定义实现类，创建该类对象作


为参数传入
如果对于这个接口或抽象类，会有多种实现方式，定义很多实现类会导致代码很长复


用性差，此时使用匿名内部类比较方便
⑷        匿名内部类常见用途
监听器或回调：配合接口和匿名内部类实现
举例：需求:烧开水
普通方式：用锅烧水，每个1分钟看一眼是否开了
监听器方式：用水壶烧开水，不用看，水开了水壶会响
⑸实际用途：
第三方登录，如QQ登录，微信登录，要使用第三方sdk：
登录的过程你不能做到，只有腾讯的开发人员知道，你只能调用login方法
登录是否成功，你可能需要给用户不同的提示，而腾讯不知道你是提示是什么，所以


暴露给你一个回调方法，你直接重写登录成功或失败的场景
Day05(2017-12-19)(API)
第一章object类&System类
1.1、object类
所有类的父类
1.1.1概述
1.1.2、获取字节码对象的方式
1、通过object类的getClass()方法获取                  对象.getclass()
2、通过类名调用属性class来获取                            类名.class;
3、通过Class类的静态方法forname()来获取          Class类的静态方法forName


(String  类的全名)
1.1.3、toString（）方法返回字符串的表现形式
由于toString方法返回的结果是内存地址，而在开发中，需要重写
Getclass();返回一个字解码对象
Integer.toHexString():返回指定参数的十六进制字符串形式
Hashcode():返回该对象的哈希码值（内部地址）
1.1.4、equals()方法（指示其他某个对象是否与此相等）
两个对象的内存地址在比较
重写之后是根据对象的属性进行比较
1.2、System类
System类包含一些有用的类字段和方法，不能被实例化
1.2.1、成员方法(Arraycopy,currentTimeMilllis,exit)
①Arraycopy（复制数组）
Static void arraycopy(Object src,srcPos,Object dest,destpos,int length):   


  (从src源数组的srcPos索引开始，复制length个元素)
Src：源数组
SrcPos:指定从哪个索引位置开始复制
Dest:目标数组
Destpos:指定目标数组接收元素的索引位置
Length：目标数组接收元素的个数
②        currentTimeMillis（返回当前系统时间）
以毫秒值返回当前系统时间（1970-1-1:0:0:0至今过了多少毫秒）
③        exit（终止虚拟机的运行）
④        system.exit（0）//退出
第2章 日期相关类
2.1、Date类
Date:表示特定的瞬间，精确到毫秒，他可以通过方法来设定自己所表示的时间，可


以表示任意的时间
2.1.1、Date类的构造方法
Date（）：创建的是一个表示当前系统时间的Date对象
Date（long date）:根据“指定时间”创建Date对象
Date d=new Date();
Syso(d);//输出当前系统的时间
2.1.2、Data类常用方法（①void setTime(long time),②long get time()）
毫秒值---Date
设置
返回值是void，参数long
Void setTime(long time)
Date(long date)
Date---毫秒值
获取
返回long，无参数
Long getTime()
2.2、DataFormat类和SimpledateFormat
2.2.1、DateFormat和SimpleDateFormat的常用方法
SimpleDateFormat（）构造方法
SimpleDateFormat（）用默认的模式和默认语言环境的日期格式符号构造


SimpleDateFormat
SimpleDateFormat（String pattern）用给定的模式和默认语言环境的日期格式符号


构造
DateFormat类方法
（String）Format(Date data)将一个Date格式化为日期/时间字符串
Date parse（String source）从给定字符串的开始解析文本，一生成一个日期
2.3Calendar类(日历类)
2.3.1、Calendar概述
Canlendar类时通过静态方法创建的
创建对象
Canlendar c= Canlendar.getlnstance();//返回当前时间                        


                                                                           


                                                                           


                                                                           


                                                                          
静态字段：表示时间的某个部分
Static YEAR：年份
Static MONTH：月份注意月份数值是0到11所以+1
Static DAY_OF_MONTH:日期
Static HOUR小时（12小时制）
Static HOUR_OF_DAY:小时（24小时制）
Static MINITE：分钟
Static SECOND：秒
Canlendar类常用成员方法（add，get，getinstance,getTime,set）
Int get(int field):返回给定日历字段的值
Void set（ int field,int value）将给定的日历字段设置为给定值（修改）
Void add（int field，int amount）：添加 负数为减少
2.3.2、Calendar类常用方法
第三章包装类和正则表达式
3.1包装类
封装了基本数据类型的类，提供了更多复杂的方法和变量
同时将基本类型的使用转换为类的面向对象的方式
基本数据类型与其包装类的对应关系
Byte     Byte
short    Short
char     Character
int      IntValue
long      Long
float     Float
double     Double
Boolean    Boolean


3.2、包装类的常用方法
构造方法：Integer(int value) 构造一个新分配Integer对象，它表示指定的int值


。
Integer（String s）构造一个新分配的Integer对象，它表示String参数所指示的


int值
Integer(String ----int)
方式1：int intvalue（）
方式2：static intparseInt(String s)
Int ----String
方式1：+“”
方式2：String toString()
方式3：


成员方法：int value（）以int类型返回该Integer的值
Static int   parseInt(Stirng s)将字符串参数作为有符号的十进制整数进行解析
String toString（）返回一个表示该Integer值得String对象
Eg:将String转换为int
Int i2=Integer.parseInt(“30”);
将int转换为String
String i3=Integer.toString(40);


3.3、包装类的自动装箱与拆箱
自动装箱：基本数据类型可以自动转换为包装类
Integer i=new integer（10）
Integer i=Integer.valueof(10)
自动拆箱：包装类可以自动转换为基本数据类型
Integer i=10;int a=I;
Int a=i.intValue();
自动拆箱的应用场景
集合只能存储引用数据类型，但有了自动拆箱，基本类型也可以转换为包装类存入集


合中
3.4、正则表达式
3.4.1、正则表达式概述
是一种用于匹配字符串的规则
Pattern类：创建正则表达式模板，内有正则表达式规则
3.4.2、正则表达式匹配规则
①字符：x
含义：代表的是字符x
Eg:匹配规则为"a"，那么需要匹配的字符串内容就是”a”
②字符：\\
含义：代表的是反斜线'\'
匹配规则为"\\"，那么需要匹配的字符串内容就是” \”
③[abc]
含义：代表的是字符a、b、c、
匹配规则为"[abc]"，那么需要匹配的字符串内容就是字符a,或者字符b,或字符c中的


一个
3.4.4、        判断字符串中间的字符是否是元音字母
3.4.4、        切割字符串
String类
String[] split(String regex): 按照正则表达式切分当前字符串为多个部分, 返回


每个部分组成的字符串数组, 其中不包含分隔符
Day06(2017-12-20)(集合)
第一章集合和迭代器
1.1集合体系结构,
集合：
是一个统称，包含很多集合的实现类，根据不同数据结构，提供了不同的集合类
数据结构：
数据的组织和存储方式
体系结构：
        将不同的集合实现类的共性向上抽取出父类，从而形成一种体系
由于不同的数据结构（数据的组织，存储方式，所以Java为我们提供了不同的集合，
但是不同的集合他们的功能都是相似，不断的向上提取，将共性提取出来，这就是集


合体系结构形成的原因。
1.2、Collection中常用功能(接口)
//创建集合对象Collection  c=new ArrayList();多态，父类引用指向子类对象
增  ①Boolean add(object):向集合中添加元素
②Void clear();清空集合中所有元素
判断  ③Boolean contains(Object):判断集合中是否包含某个元素
④Boolean isEmpty();判断集合中的元素是否为空
删     ⑤Boolean remove(Object)根据元素的内容来删除某个元素
获取个数⑥Int size();获取集合的长度
转换    ⑦Object【】toarray():能够将集合转换为数组并把集合中元素存储到数组


中
1.3、迭代器
Iterator接口：（可以用于遍历集合）
作用：提供遍历集合的安全方式
获取迭代器：使用集合对象调用Interator<E>iterator()方法
成员方法
Boolean hasNext():判断是否有下一个元素
E next():返回下一个元素
Void remove（）：从迭代器指向的collection中移除迭代器返回的最后一个元素
集合的遍历：
①Toarray（），可以把数组集合转换为数组，然后for循环遍历数组即可
②Iterator(),可以返回一个迭代器对象来迭代集合 hasNext（）next()
注意：Exception in thread "main" java.util.NoSuchElementException
*          使用next方法获取下一个元素，如果没有元素可以获取，则出现


NoSuchElementException
        
1.4、并发修改异常
并发修改异常（ConcurrentModificationException）
并发：并行发生，即同时发生
修改：指的是回改变集合长度的操作
        增加元素
        删除元素
        清空元素
List的set(int index,object o)方法可以修改集合中某个索引出的元素值，但是并


不会改变集合的长度，所以不会发生并发修改异常
发生的原因：
迭代器依赖于集合，相当于集合的一个副本，当迭代器在操作时，如果发现迭代器的


副本和集合不一样，则会抛出并发修改异常
当使用迭代器遍历集合的时候，使用集合中的增加/删除 方法，导致并发修改异常
解决方案：
                        不使用迭代器
                        在使用迭代器进行遍历的时候使用迭代器来进行修改
List接口
列表是Collection的子接口
特点：元素存取有序，元素可以重复，有索引
依然使用迭代器遍历，那么就需要使用Iterator的子接口ListIterator来实现向集合


中添加
第二章增强for泛型
2.1、泛型
使用集合存储自定义对象并遍历
* 由于集合可以存储任意类型的对象，当我们存储了不同类型的对象，就有可能在


转换的时候出现类型转换异常，
* 所以java为了解决这个问题，给我们提供了一种机制，叫做泛型
2.1.1范型的引入（好处、作用）
好处：避免类型转换问题
减少警告
简化代码书写
作用：用于明确数据类型
将运行时才发生的类型装换问题，提前到编译时期
2.1.2范型的使用
如何使用：出现<某个字母>的地方，就可以使用具体的数据类型替代这个字母
为什么泛型写为<E>?
⑴只是在集合相关的泛型中会使用E,E是Element的缩写，表示元素，说明这个泛型的


类型表示的是集合中元素的数据类型
⑵在其他地方有可能还会出现<T>等其他字母，T是Type的缩写，说明这个泛型表示的


是数据类型
⑶英文字母并不一定对应单词的缩写，只是为了见名知义，写成任意的都可以
2.2foreach的概述（也叫增强for循环）
作用：遍历数组和集合
格式：for(元素类型 变量名：数组或集合对象){
//每次循环都会遍历一个元素，保存到变量名中
}
注意：增强for循环中不能修改集合（改变集合长度），会发生并发修改异常
原因：因为for增强for循环内部使用的是迭代器进行迭代
优缺点：优点：简单快捷的拿到每一个元素
缺点：循环过程中不能修改元素
不能像普通for循环那样使用索引
第三章常见数据结构
3.1数组
数组的特点：
数组的长度一但确定则不可改变
数组中的元素都有整数索引
数组只能存储同一类型的元素
数组即可以存储基本数据类型，也可以存储引用数据类型
如何获取元素3？
可以通过索引获取，arr[2];
想要在元素3后边添加一个新的元素8怎么办？
                首先创建一个新的数组，长度是原先数组长度+1
                遍历原先的数组，并且插入到新的数组中
                当碰到元素3的时候，在元素3后边添加新的元素8
最后把剩余的元素添加到元素8后边即可
数组 查找快，
增删慢
3.2链表
采用该结构的集合，对元素的存取有如下的特点：
⑵        多个节点之间，通过地址进行连接
⑵查找元素慢：想查找某个元素，需要通过连接的节点，依次向后查找指定元素
⑶增删元素快：改地址值
3.3、数组和链表在存储上的区别
⑴数组中元素的内存地址值是连续的
在查找是只要找到索引0位置的元素的地址值，后面按地址值往后找即可，
⑵链表中元素的内存地址值可以不连续
好比链表打游戏找到第一个才知道第二个人在哪里
⑶        链表还分双向链表和单向链表
双向链表中药柜结点会同时保存上一个结点和下一个结点的地址，可以从前往后找，


也可以从后往前找
单向列表只能保存上一个结点或下一个结点之一，只能往一个方向找
3.4、栈和队列
栈（stack）特点：先进后出（子弹夹）
队列(queue)  特点：先进先出  （管道口）
第4章List子体系
4.1、List子体系特点
有序的
有整数索引
允许重复
4.2、List的特有功能
Void add(int index,E element) 添加元素
E get（int index）获取元素
E remove（int index）删除元素
E set将指定索引位置的元素（修改元素）
4.3、List的常用子类
ArrayList：底层是数组结构（查询快，增删慢）
LinkedList：底层是链表（查询慢，增删快）
4.4、Linked特有功能
LinkedList底层使用的是链表结构，因此增删快，查询相对ArrayList慢
Void addFirst():向链表的头部添加元素
Void addList（）：向链表的尾部添加元素
E getfirst():获取链头的元素，不删除元素
E getLast（）:获取链尾的元素，不删除元素
E removeFirst（）：返回链头的元素并删除链头的元素
E removeLast():返回链尾的元素并删除链尾的元素
4.5、使用LinkedList实现栈和队列
栈：先进后出
进：元素添加到末尾addLast（E e）
出：删除末尾的元素 removelast（E e）
队列：先进先出
进：元素添加到末尾 addalist(E e)
出：删除开头的元素,E removefirst()

---

欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2