- 博客(0)
- 资源 (38)
- 收藏
- 关注
RSS订阅创建用户只分配select 权限
创建一个用户，只分配select 权限
1. 用sys用户登陆， 创建用户并赋权限
create user cc551it identified by "cc551it";
grant connect,resource to cc551it;
grant create synonym to cc551it;
2. 用newccs用户登陆，对cc551it 用户赋select 权限
Select 'grant select on newccs.'||table_name||' to cc551it;' from user_tables;
2018-08-08
【09-异常处理】
异常概述
•异常处理已经成为衡量一门语言是否成熟的标准之一，目前的主流编程语言如C++、C#、Ruby、
Python等，大都提供了异常处理机制。增加了异常处理机制后的程序有更好的容错性，更加健壮。
传统错误处理的缺陷
•传统错误处理机制，主要如下两个缺点：
–无法穷举所有异常情况：因为人类知识的限制，异常情况总比可以考虑到的情况多，总有“漏网之鱼”的异常情况，所以程序总是不够健壮。
–错误处理代码和业务实现代码混杂：这种错误处理和业务实现混杂的代码严重影响程序的可读性，会增加程序维护的难度。
使用try...catch捕获异常
•执行try块里的业务逻辑代码时出现异常，系统自动生成一个异常对象，该异常对象被提交给Java运
行时环境，这个过程被称为抛出（throw）异常。
•Java运行时环境收到异常对象时，会寻找能处理该异常对象的catch块，如果找到合适的catch块并
把该异常对象交给该catch块处理，那这个过程被称为捕获（catch）异常；如果Java运行时环境找
不到捕获异常的catch块，则运行时环境终止，Java程序也将退出。
异常的捕捉流程
Java的异常体系
访问异常信息
•如果程序需要在catch块中访问异常对象的相关信息，可以通过调用catch后异常形参的方法来获
得。当Java运行时决定调用某个catch块来处理该异常对象时，会将该异常对象赋给catch块后的异
常参数，程序就可以通过该参数来获得该异常的相关信息。
•所有异常对象都包含了如下几个常用方法：
–getMessage()：返回该异常的详细描述字符串。
–printStackTrace()：将该异常的跟踪栈信息输出到标准错误输出。
–printStackTrace(PrintStream s)：将该异常的跟踪栈信息输出到指定输出流。
–getStackTrace()：返回该异常的跟踪栈信息。
异常处理
复制代码
try
{
需要检测的代码；
}
catch(异常类 变量)
{
异常处理代码；
}
finally
{
一定会执行的代码；
}
复制代码
Finally代码块只有一种情况不会被执行。就是在之前执行了System.exit(0)。
Java 7提供的多异常捕捉
•在Java 7以前，每个catch块只能捕捉一个异常。从Java 7开始，一个catch块可以捕捉多个异常。
–catch(异常1 | 异常 2 | 异常3 ex)
–{
–}
•多个异常之间用竖线隔开。
•多异常捕捉时，异常变量之前有隐式final修饰。
本文原创作者：pipi-changing
本文原创出处：http://www.cnblogs.com/pipi-changing/
使用finally回收资源
•程序在try块里打开了一些物理资源（例如数据库连接、网络连接和磁盘文件等），这些物理资源都
必须显式回收。
•为了保证一定能回收try块中打开的物理资源，异常处理机制提供了finally块。不管try块中的代码是
否出现异常，也不管哪一个catch块被执行，finally块总会被执行。
异常处理的嵌套
•异常处理流程代码可以放在任何能放可执行性代码的地方，因此完整的异常处理流程既可放在try块
里，也可放在catch块里，也可放在finally块里。
•异常处理嵌套的深度没有很明确的限制，但通常没有必要使用超过两层的嵌套异常处理，层次太深的
嵌套异常处理没有太大必要，而且导致程序可读性降低。
Java 7的自动关闭资源的try语句
–try(
– // 此处声明的资源， 系统可以自动关闭它。
–)
–{
– //
–}
•对于自动关闭资源的try语句， 可以没有catch和finally——try块可以孤独地存在。
•自动关闭资源的try语句，有两个注意点：
–只有放在try后面的圆括号里的资源才会被关闭。
–能被自动关闭的资源必须实现Closeable或AutoCloseable接口。
Checked异常与Runtime异常
•Java的异常被分为两大类：Checked异常和Runtime异常（运行时异常）。所有
RuntimeException类及其子类的实例被称为Runtime异常；不是RuntimeException类及其子类
的异常实例则被称为Checked异常。
Checked异常的处理
•当前方法明确知道如何处理该异常，程序应该使用try...catch块来捕获该异常，然后在对应的catch
块中修改该异常。
•当前方法不知道如何处理这种异常，应该在定义该方法时声明抛出该异常。
Runtime异常的处理
•Runtime异常则更加灵活，Runtime异常无需显式声明抛出。
•如果程序需要捕捉Runtime异常，也可以使用try...catch块来捕捉Runtime异常。
使用throws声明抛出异常
•throws声明抛出异常的思路是：当前方法不知道应该如何这种类型的异常，该异常应该由上一级调
用者处理，如果main方法也不知道应该如何处理这种类型的异常，也可以使用throws声明抛出异
常，该异常将交给JVM处理。JVM对异常的处理方法是：打印异常跟踪栈信息，并中止程序运行，这
就是前面程序在遇到异常后自动结束的原因。
•throws声明抛出只能在方法签名中使用，throws可以声明抛出多个异常类，多个异常类之间以逗
号隔开。throws声明抛出的语法格式如下
–throws ExceptionClass1 , ExceptionClass2...
抛出异常
•如果需要在程序中自行抛出异常，应使用throw语句，throw语句可以单独使用，throw语句抛出
的不是异常类，而是一个异常实例，而且每次只能抛出一个异常实例。throw语句的语法格式如下：
–throw ExceptionInstance;
•如果throw语句抛出的异常是Checked异常，则该throw语句要么处于try块里，显式捕获该异常
，要么放在一个带throws声明抛出的方法中，即把该异常交给该方法的调用者处理。
Java 7增强的throw语句
–try
–{
– new FileInputStream(“a.txt”);
–}
–Catch(Exception ex)
–{
– ex.printStackTrace();
– throw ex; //①
–}
•从JDK 7开始，Java编译器可以只能地识别①号代码处抛出的异常只是FileNotFoundException异常。
自定义异常类
•程序很少会自行抛出系统异常，因为异常的类名通常包含了该异常的有用信息。所以在选择抛出什么
异常时，应该选择合适的异常类，从而可以明确地描述该异常情况。在这种情形下，应用程序常常需要
抛出自定义异常。
•用户自定义异常都应该继承Exception基类，如果希望自定义Runtime异常，则应该继承
RuntimeException基类。定义异常类时通常需要提供两种构造器：一个是无参数的构造器；另一个
是带一个字符串参数的构造器，这个字符串将作为该异常对象的详细说明（也就是异常对象的
getMessage方法的返回值）。
异常链
•当业务逻辑层访问持久层出现SQLException异常时，程序不应该把底层的SQLException异常传
到用户界面，原因有如下两个：
–对于正常用户而言，他们不想看到底层SQLException，SQLException对他们使用该系统没
有任何帮助。
–对于恶意用户而言，将SQLException暴露出来是一种不安全的。
Java的异常跟踪栈
•异常对象的printStackTrace方法用于打印异常的跟踪栈信息，根据printStackTrace方法的输出
结果，我们可以找到异常的源头，并跟踪到异常一路触发的过程。
•面向对象的应用程序运行时，经常会发生一系列方法调用，从而形成“方法调用栈”，异常的传播则与
相反：只要异常没有被完全捕获（包括异常没有被捕获，或异常被处理后重新抛出了新异常），异常从
发生异常的方法逐渐向外传播，首先传给该方法的调用者，该方法调用者再次传给其调用者……直至最
后传到 main方法，如果main方法依然没有处理该异常，JVM会中止该程序，并打印异常的跟踪栈信
息。
异常处理规则
•不要过度使用异常
•不要使用过于庞大的try块
•避免使用Catch All语句
•不要忽略捕获到异常
。。。。。。。。。。。。。
2018-07-03
【05-面向对象(下)】
基本数据类型的包装类
•八大数据类型的包装类分别为：Byte、Short、Integer、Long、Character、 Float、Double、Boolean。
把基本数据类型变量包装类实例是通过对应包装类的构造器来实现的，不仅如此，8个包装类中除了
Character之外，还可以通过传入一个字符串参数来构建包装类对象。
•如果希望获得包装类对象中包装的基本类型变量，则可以使用包装类提供的XxxValue()实例方法。
自动装箱与自动拆箱
•JDk还提供了自动装箱和自动拆箱。自动装箱就是把一个基本类型的变量直接赋给对应的包装类变量，自动拆箱
则与之相反。
•包装类还可以实现基本类型变量和字符串之间的转换，除了Character之外的所有包装类都提供了一个
parseXxx(String s)静态方法。
•如果将基本类型转换为这符串，只需在后面加+ “”进行连接运算。
Java 7对包装类的增强
•Java 7为所有包装类增加一个新方法： compare(x , y)的方法。该方法用于比较两个包装类实例，当x>y，
返回大于0的数；当x==y，返回0；否则返回小于0的数。
对象的方法
•打印对象和toString方法：toString方法是系统将会输出该对象的“自我描述”信息，用以告诉外界对象具有的状
态信息。
•Object 类提供的toString方法总是返回该对象实现类的类名 + @ +hashCode值。
•==和equals比较运算符：==要求两个引用变量指向同一个对象才会返回true。equals方法则允许用户提供自
定义的相等规则。
•Object类提供的equals方法判断两个对象相等的标准与==完全相同。因此开发者通常需要重写equals方法。
类成员
•在java类里只能包含Field,方法,构造器,初始化块,内部类（接口、枚举）等5种成员。 用static修饰的类成员属
于类成员，类Field既可通过类来访问，也可以通过类的对象来访问。当通过对象来访问类属性时，系统会在底
层转换为通过该类来访问类 属性。
类成员规则
•类成员并不是属于实例，它是属于类本身的。只要类存在，类成员就存在。
•即使通过null对象来访问类成员，程序也不会引发NullPointerException。
类成员不能访问实例成员。
单例类
•如果一个类始终只能创建一个对象，称为单例类。须符合以下几个条件：
–1.我们把该类的构造器使用Private修饰，从而把该 类的所有构造器隐藏起来。
–2.则需要提供一个public方法作为该类的访问点，用于创建该类的对象，且必须使用static修饰
–3.该类还必须缓存已经创建的对象，必须用static修饰
final变量
•final修饰变量时，表示该变量一旦获得 初始值之后就不可被改变。
•final既可修饰成员变量，也可以修饰局部变量。
final修饰成员变量
•成员变量是随类的初始化或对象初始化而初始化的。final修饰的成员变量必须由程序员指定初始值。
•对于类属性而言，要么在静态初始化中初始化，要么在声明该属性时初始化。
•对于实例属性，要么在普通初始化块中指定初始值。要么在定义时、或构造器中指定初始值。
final修饰局部变量
•使用final修饰局部变量时既可以在定义时指定默认值，也可以不指定默认值。
•给局部变量赋初始值，只能一次，不能重复。
final修饰基本类型和引用类型
•当使用final修饰基本数据类型时，不能对其重新赋值，不能被改变。
•但对引用类型的变量而言，它仅仅保存的是一个引用，final只能保证他的地址不变，但不能保证对象，所以引用
类型完全可以改变他的对象。
可执行“宏替换”的final变量
•对一个final变量来说，不管它是类变量、实例变量，还是局部变量，只要该变量满足3个条件，这个final变量就
不再是一个变量，而是相当于一个直接量。
–使用final修饰符修饰；
–在定义该final变量时指定了初始值；
–该初始值可以在编译时就被确定下来。
final方法
•final方法
•final 修饰的方法不可以被重写。
•final 修饰的方法仅仅是不能重写，但它完全可以被重载。
•final 修饰的类不可以被继承
不可变的类
•不可变的类要满足以下几个条件：
–1.使用private和final修饰符来修饰该类的属性
–2.提供带参数的构造器，用于根据传入参数来初始化类里的属性
–3.仅为该类的属性提供getter方法，不要为该类的属性提供setter方法，因为普通方法无法修改final修饰的
属性
–4.如有必要，重写Object类中hashCode 和equals
•缓存实例的不可变类：如果程序经常需要使用不可变类的实例，则可对实例进行缓存。
抽象方法和抽象类
•抽象方法和类都必须使用abstract来修饰，有抽象方法的类只能定义成抽象类，抽象里也可以没有抽象方法。
• 抽象类不能被实例化，可以通过其子类给他赋值，普通类里有的抽象里也有，定义抽象方法只需在普通方法上增
加abstract修饰符，并把普通方法的方法体（也就是方法后花括号括起来的部分）全部去掉，并在方法后增加分号
即可。
抽象类的特征
•抽象类的特征：有得有失，得到了新能力，可以拥有抽象方法；失去了创建对象的能力。
抽象类的作用
•抽象类代表了一种未完成的类设计，它体现的是一种模板。
•抽象类与模板模式。
接口的概念
•接口定义的是多个类共同的行为规范，这些行为是与外部交流的通道，这就意味着接口里通常是定义一组公用的
方法。
•接口体现了规范与实现分离的设计。
接口的定义
•和类定义不同，定义接口不再用class关键字，而是使用interface关键字。语法如下：
•[修饰符] interface接口名 extends 父接口1,父接口2 ...
•{
• 零个到多个常量定义...
• 零个到多个抽象方法定义...
• 零个到多个内部类、接口、枚举定义...
• 零个到多个默认方法或类方法定义...
•}
接口里的成分
•在定义接口时，接口里可以包含成员变量（只能是常量），方法(只能是抽象实例方法、类方法或默认方法），内
部类（包括内部接口、枚举类
–常量都是：public static final修饰
–方法都是：public abstract 修饰
–内部的类：public static
接口的继承
•接口的继承和类继承不一样，接口完全支持多继承，子接口扩展某个父接口将会获得父接口的所有抽象方法，常
量属性，内部类和枚举类定义。
使用接口
•接口可以用于声明引用类型的变量，但接口不能用于创建实例。
•当使用接口来声明引用类型的变量时，这个引用类型的变量必须引用到其实现类的对象。
•一个类可以实现一个或多个接口，继承使用extends关键字，实现接口则使用implements关键字。
实现接口
•一个类实现了一个或多个接口之后，这个类必须完全实现这些接口里所定义的全部抽象方法（也就是重写这些抽
象方法）；
•否则，该类将保留从父接口那里继承到的抽象方法，该类也必须定义成抽象类。
接口和抽象类的相似性
•接口和抽象类都不能被实例化，它们都位于继承树的顶端，用于被其他类实现和继承。
•接口和抽象类都可以包含抽象方法，实现接口或继承抽象类的普通子类都必须实现这些抽象方法。
接口与抽象类的区别
•接口里只能包含抽象方法，不同包含已经提供实现的方法；抽象类则完全可以包含普通方法。
•接口里不能定义静态方法；抽象类里可以定义静态方法。
•接口里只能定义静态常量属性，不能定义普通属性；抽象类里则既可以定义普通属性，也可以定义静态常量属
性。
•接口不包含构造器；抽象类里可以包含构造器，抽象类里的构造器并不是用于创建对象，而让其子类调用这些构
造器来完成属于抽象类的初始化操作。
•接口里不能包含初始化块，但抽象类则完全可以包含初始化块。
•一个类最多只能有一个直接父类，包括抽象类；但一个类可以直接实现多个接口，通过实现多个接口可以弥补
Java单继承的不足。
面向接口编程
•接口体现了规范与实现分离的原则。充分利用接口可以很好地提高系统的可扩展性和可维护性。
•接口与简单工厂模式、命令模式等。
内部类
•我们把一个类放在另一个类的内部定义，这个定义在其他类内部的类就被称为内部类，有的也叫嵌套类，包含内
部类的类也被称为外部类有的也叫宿住类。
•内部类提供了更好的封装，内部类成员可以直接访问外部类的私有数据，因为内部类被当成其他外部类成员。
•匿名内部类适合用于创建那些仅需要一次使用的类。
非静态内部类
•定义内部类非常简单，只要把一个类放在另一个类内部定义即可。
•当在非静态内部类的方法内访问某个变量时，系统优先在该方法内查找是否存在该名字的局部变量，如果存在该
名字的局部变量，就使用该变量，如果不存在，则到该方法所在的内部类中查找是否存在该名字的属性，如果存在
则使用该属性。
•总之，第一步先找局部变量，第二步，内部类的属性，第三步。外部类的属性。
本文原创作者：pipi-changing
本文原创出处：http://www.cnblogs.com/pipi-changing/
静态内部类
•如果用static修饰一个内部类，称为静态内部类。
•静态内部类可以包含静态成员，也可以包含非静态成员。所以静态内部类不能访问外部类的实例成员，只能访问
外部类的类成员。
•静态内部类的对象寄存在外部类里，非静态内部类的对象寄存在外部类实例里
使用内部类
•1.在外部类内部使用内部类－不要在外部类的静态成员中使用非静态内部类，因为静态成员不能访问非静态成
员。
• 2.在外部类以外使用非静态内部类。
–private 修饰的内部类只能在外部类内部使用。
–在外部类以外的地方使用内部类，内部类完整的类名应该OuterClass.InnerClass.
–在外部类以外的地方使用非静态内部类创建对象的语法如下：OuterInstance.new InnerConstructor()
–在外部类以外的地方使用静态内部类创建对象的语法如下：new OuterClass.InnerConstructer();
局部内部类
•如果把一个内部类放在方法里定义，这就是局部内部类，仅仅在这个方法里有效。
•局部内部类不能在外部类以外的地方使用，那么局部内部类也不能使用访问控制符和static修饰
匿名内部类
•匿名内部类适合创建那种只需要一次使用的类，定义匿名内部类的语法格式如下：
•new 父类构造器（实例列表) |实现接口）
•{
• //匿名内部类的 类体部分
•}
•匿名内部类不能是抽象类，匿名内部类不能定义构造器。
Lambda表达式入门
•Lambda表达式主要作用就是代替匿名内部类的繁琐语法。它由三部分组成：
–形参列表。形参列表允许省略形参类型。如果形参列表中只有一个参数，甚至连形参列表的圆括号也可以省略。
–箭头（->），必须通过英文等号和大于符号组成。
–代码块。如果代码块只有包含一条语句，Lambda表达式允许省略代码块的花括号，如果省略了代码块的花括
号，这条语句不要用花括号表示语句结束。Lambda代码块只有一条return语句，甚至可以省略return关键字。
Lambda表达式需要返回值，而它的代码块中仅有一条省略了return的语句，Lambda表达式会自动返回这条语句的
值。
Lambda表达式与函数式接口
•如果采用匿名内部类语法来创建函数式接口的实例，只要实现一个抽象方法即可，在这种情况下即可采用
Lambda表达式来创建对象，该表达式创建出来的对象的目标类型就是这个函数式接口。
•Lambda表达式有如下两个限制：
–Lambda表达式的目标类型必须是明确的函数式接口。
–Lambda表达式只能为函数式接口创建对象。Lambda表达式只能实现一个方法，因此它只能为只有一个抽
象方法的接口（函数式接口）创建对象。
•为了保证Lambda表达式的目标类型是一个明确的函数式接口，可以有如下三种常见方式：
–将Lambda表达式赋值给函数式接口类型的变量。
–将Lambda表达式作为函数式接口类型的参数传给某个方法。
–使用函数式接口对Lambda表达式进行强制类型转换。
方法引用与构造器引用
种类
示例
说明
对应的Lambda表达式
引用类方法
类名::类方法
函数式接口中被实现方法的全部参数传给该类方法作为参数。
(a,b,...) -> 类名.类方法(a,b, ...)
引用特定对象的实例方法
特定对象::实例方法
函数式接口中被实现方法的全部参数传给该方法作为参数。
(a,b, ...) -> 特定对象.实例方法(a,b, ...)
引用某类对象的实例方法
类名::实例方法
函数式接口中被实现方法的第一个参数作为调用者，后面的参数全部传给该方法作为参数。
(a,b, ...) ->a.实例方法(b, ...)
引用构造器
类名::new
函数式接口中被实现方法的全部参数传给该构造器作为参数。
(a,b, ...) ->new 类名(a,b, ...)
Lambda表达式与匿名内部类
•Lambda表达式与匿名内部类存在如下相同点：
–Lambda表达式与匿名内部类一样，都可以直接访问“effectively final”的局部变量，以及外部类的成员变
量（包括实例变量和类变量）。
–Lambda表达式创建的对象与匿名内部类生成的对象一样， 都可以直接调用从接口继承得到的默认方法。
•Lambda表达式与匿名内部类主要存在如下区别：
–匿名内部类可以为任意接口创建实例——不管接口包含多少个抽象方法，只要匿名内部类实现所有的抽象方
法即可。但Lambda表达式只能为函数式接口创建实例。
–匿名内部类可以为抽象类、甚至普通类创建实例，但Lambda表达式只能为函数式接口创建实例。
–匿名内部类实现的抽象方法的方法体允许调用接口中定义的默认方法；但Lambda表达式的代码块不允许调
用接口中定义的默认方法。
手动实现枚举类
•可以采用如下设计方式：
–通过private将构造器隐藏起来。
–把这个类的所有可能实例都使用public static final属性来保存。
–如果有必要，可以提供一些静态方法，允许其他程序根据特定参数来获取与之匹配实例。
JDK 5新增的枚举支持
•J2SE1.5新增了一个enum关键字，用以定义枚举类。正如前面看到，枚举类是一种特殊的类，它一样可以有自
己的方法和属性，可以实现一个或者多个接口，也可以定义自己的构造器。一个Java源文件中最多只能定义一个
public访问权限的枚举类，且该Java源文件也必须和该枚举类的类名相同。
枚举类
•枚举类可以实现一个或多个接口，使用enum定义的枚举类默认继承了java.lang.Enum类，而不是继承Object
类。其中java.lang.Enum类实现了java.lang.Serializable和java.lang. Comparable两个接口。
•枚举类的构造器只能使用private访问控制符，如果省略了其构造器的访问控制符，则默认使用private修饰；如
果强制指定访问控制符，则只能指定private修饰符。
•枚举类的所有实例必须在枚举类中显式列出，否则这个枚举类将永远都不能产生实例。列出这些实例时系统会自
动添加public static final修饰，无需程序员显式添加。
•所有枚举类都提供了一个values方法，该方法可以很方便地遍历所有的枚举值。
枚举类的属性、方法和构造器
•枚举类也是一种类，只是它是一种比较特殊的类，因此它一样可以使用属性和方法。
•枚举类通常应该设计成不可变类，也就说它的属性值不应该允许改变，这样会更安全，而且代码更加简洁。为
此，我们应该将枚举类的属性都使用private final 修饰。
•一旦为枚举类显式定义了带参数的构造器，则列出枚举值时也必须对应地传入参数。
实现接口的枚举类
•枚举类也可以实现一个或多个接口。与普通类实现一个或多个接口完全一样，枚举类实现一个或多个接口时，也
需要实现该接口所包含的方法。
•如果需要每个枚举值在调用同一个方法时呈现出不同的行为方式，则可以让每个枚举值分别来实现该方法，每个
枚举值提供不同的实现方式，从而让不同枚举值调用同一个方法时具有不同的行为方式。
包含抽象方法的枚举类
•可以在枚举类里定义一个抽象方法，然后把这个抽象方法交给各枚举值去实现即可。
•枚举类里定义抽象方法时无需显式使用abstract关键字将枚举类定义成抽象类，但因为枚举类需要显式创建枚举
值，而不是作为父类，所以定义每个枚举值时必须为抽象方法提供实现，否则将出现编译错误。
垃圾回收机制
•垃圾回收机制只负责回收堆内存中对象，不会回收任何任何物理资源（例如数据库连接，网络IO等资源）。
•程序无法精确控制垃圾回收的运行，垃圾回收会在合适时候进行垃圾回收。当对象永久性地失去引用后，系统就
会在合适时候回收它所占的内存。
•垃圾回收机制回收任何对象之前，总会先调用它的finalize方法，该方法可能使该对象重新复活（让一个引用变量
重新引用该对象），从而导致垃圾回收机制取消回收
对象在内存中的状态
•激活状态：当一个对象被创建后，有一个以上的引用变量引用它。则这个对象在程序中处于激活状态，程序可通
过引用变量来调用该对象的属性和方法。
•去活状态：如果程序中某个对象不再有任何引用变量引用它，它就进入了去活状态。在这个状态下，系统的垃圾
回收机制准备回收该对象所占用的内存，在回收该对象之前，系统会调用所有去活状态对象的finalize方法进行资
源清理，如果系统在调用finalize方法重新让一个引用变量引用该对象，则这个对象会再次变为激活状态；否则该
对象将进入死亡状态。
•死亡状态：当对象与所有引用变量的关联都被切断，且系统会调用所有对象的finalize方法依然没有使该对象变成
激活状态，那这个对象将永久性地失去引用，最后变成死亡状态。只有当一个对象处于死亡状态时，系统才会真正
回收该对象所占有的资源。
强制垃圾回收
•强制系统垃圾回收有如下两个方法：
–调用System类的gc()静态方法：System.gc()
–调用Runtime对象的gc()实例方法：Runtime.getRuntime().gc()
finalize方法
•finalize方法有如下四个特点：
–永远不要主动调用某个对象的finalize方法，该方法应交给垃圾回收机制调用。
–finalize方法的何时被调用，是否被调用具有不确定性。不要把finalize方法当成一定会被执行的方法。
–当JVM执行去活对象的finalize方法时，可能使该对象，或系统中其他对象重新变成激活状态。
–当JVM执行finalize方法时出现了异常，垃圾回收机制不会报告异常，程序继续执行。
对象的软、弱和虚引用
•强引用（StrongReference）
•软引用－软引用需要通过SoftReference类来实现，当一个对象只具有软引用时，它有可能被垃圾回收机制回
收。
•弱引用－弱引用通过WeakReference类实现，弱引用和软引用很像，但弱引用的引用级别更低。对于只有弱引
用的对象而言，当系统垃圾回收机制运行时，不管系统内存是否足够，总会回收该对象所占用的内存。
•虚引用－虚引用通过PhantomReference类实现，虚应用完全类似于没有引用。虚引用对对象本身没有太大影
响，对象甚至感觉不到虚引用的存在。
修饰符的适用范围
顶层类/接口
成员属性
方法
构造器
初始化块
成员内部类
局部成员
public
√
√
√
√
√
protected
√
√
√
√
包访问控制符
√
√
√
√
○
√
○
private
√
√
√
√
abstract
√
√
√
final
√
√
√
√
√
static
√
√
√
√
strictfp
√
√
√
synchronized
√
native
√
transient
√
volatile
√
使用JAR文件的好处
•1.安全
•2.加快下载速度
•3.压缩
•4.包封装
•5.可移植性
jar命令详解
•-c 创建新文档，-t 列出存档内容的列表， -x 展开存档中的命名文件
•-u 更新已存在的存档，-v生成详细输出到标准输出上
•-f 指定存档文件名，-m 包含 来自标文件的标明信息
•-o 只存储方式：未用ZIP压缩格式
•-m 不产生所有项的清单文件，- I 为指定的jar文件产生索引信息
•-c 改变到指定的目录，
创建可执行的JAR包
•1.使用平台相关的编译器将整个应用编译成平台相关的可执行性文件
•2.为整个应用编辑一个批处理文件
关于JAR包的技巧
•相当于一个压缩文件。
•可使用WinRAR来压缩JAR包。
•也可使用WinRAR来查看JAR包。
现在贴出代码：
AutoBoxingUnboxing
Primitive2String
UnsignedTest
WrapperClassCompare
EqualTest
Person
OverrideEqualsRight
PrintObject
StringCompareTest
ToStringTest
NullAccessStatic
Singleton
Address
CacheImmutaleTest
FinalErrorTest
FinalLocalTest
FinalLocalVariableTest
FinalMethodTest
FinalReferenceTest
FinalReplaceTest
FinalVariableTest
ImmutableStringTest
IntegerCacheTest
Person
Sub extends PrivateFinalMethodTest
StringJoinTest
CarSpeedMeter
Circle extends Shape
abstract class Shape
SpeedMeter
Triangle
复制代码
public class AddCommand implements Command {
public void process(int[] target) {
int sum = 0;
for (int tmp : target) {
sum += tmp;
}
System.out.println("数组元素的总和是:" + sum);
}
}
****************************************************
public class BetterPrinter implements Output {
private String[] printData = new String[MAX_CACHE_LINE * 2];
// 用以记录当前需打印的作业数
private int dataNum = 0;
public void out() {
// 只要还有作业，继续打印
while (dataNum > 0) {
System.out.println("高速打印机正在打印：" + printData[0]);
// 把作业队列整体前移一位，并将剩下的作业数减1
System.arraycopy(printData, 1, printData, 0, --dataNum);
}
}
public void getData(String msg) {
if (dataNum >= MAX_CACHE_LINE * 2) {
System.out.println("输出队列已满，添加失败");
} else {
// 把打印数据添加到队列里，已保存数据的数量加1。
printData[dataNum++] = msg;
}
}
}
************************************************
public interface Command {
// 接口里定义的process()方法用于封装“处理行为”
void process(int[] target);
}
**********************************************
public class CommandTest {
public static void main(String[] args) {
ProcessArray pa = new ProcessArray();
int[] target = { 3, -4, 6, 4 };
// 第一次处理数组，具体处理行为取决于PrintCommand
pa.process(target, new PrintCommand());
System.out.println("------------------");
// 第二次处理数组，具体处理行为取决于AddCommand
pa.process(target, new AddCommand());
}
}
*************************************************
public class Computer {
private Output out;
public Computer(Output out) {
this.out = out;
}
// 定义一个模拟获取字符串输入的方法
public void keyIn(String msg) {
out.getData(msg);
}
// 定义一个模拟打印的方法
public void print() {
out.out();
}
}
**********************************************
interface interfaceA {
int PROP_A = 5;
void testA();
}
interface interfaceB {
int PROP_B = 6;
void testB();
}
interface interfaceC extends interfaceA, interfaceB {
int PROP_C = 7;
void testC();
}
public class InterfaceExtendsTest {
public static void main(String[] args) {
System.out.println(interfaceC.PROP_A);
System.out.println(interfaceC.PROP_B);
System.out.println(interfaceC.PROP_C);
}
}
**************************************************
public interface Output
{
// 接口里定义的成员变量只能是常量
int MAX_CACHE_LINE = 50;
// 接口里定义的普通方法只能是public的抽象方法
void out();
void getData(String msg);
// 在接口中定义默认方法，需要使用default修饰
default void print(String... msgs)
{
for (String msg : msgs)
{
System.out.println(msg);
}
}
// 在接口中定义默认方法，需要使用default修饰
default void test()
{
System.out.println("默认的test()方法");
}
// 在接口中定义类方法，需要使用static修饰
static String staticTest()
{
return "接口里的类方法";
}
}
**********************************************
public class OutputFactory {
public Output getOutput() {
// return new Printer();
return new BetterPrinter();
}
public static void main(String[] args) {
OutputFactory of = new OutputFactory();
Computer c = new Computer(of.getOutput());
c.keyIn("轻量级Java EE企业应用实战");
c.keyIn("疯狂Java讲义");
c.print();
}
}
***********************************************
public class OutputFieldTest {
public static void main(String[] args) {
// 访问另一个包中的Output接口的MAX_CACHE_LINE
System.out.println(lee.Output.MAX_CACHE_LINE);
// 下面语句将引起"为final变量赋值"的编译异常
// lee.Output.MAX_CACHE_LINE = 20;
// 使用接口来调用类方法
System.out.println(lee.Output.staticTest());
}
}
************************************************
public class PrintCommand implements Command {
public void process(int[] target) {
for (int tmp : target) {
System.out.println("迭代输出目标数组的元素:" + tmp);
}
}
}
***********************************************
// 定义一个Product接口
interface Product {
int getProduceTime();
}
// 让Printer类实现Output和Product接口
public class Printer implements Output, Product {
private String[] printData = new String[MAX_CACHE_LINE];
// 用以记录当前需打印的作业数
private int dataNum = 0;
public void out() {
// 只要还有作业，继续打印
while (dataNum > 0) {
System.out.println("打印机打印：" + printData[0]);
// 把作业队列整体前移一位，并将剩下的作业数减1
System.arraycopy(printData, 1, printData, 0, --dataNum);
}
}
public void getData(String msg) {
if (dataNum >= MAX_CACHE_LINE) {
System.out.println("输出队列已满，添加失败");
} else {
// 把打印数据添加到队列里，已保存数据的数量加1。
printData[dataNum++] = msg;
}
}
public int getProduceTime() {
return 45;
}
public static void main(String[] args) {
// 创建一个Printer对象，当成Output使用
Output o = new Printer();
o.getData("轻量级Java EE企业应用实战");
o.getData("疯狂Java讲义");
o.out();
o.getData("疯狂Android讲义");
o.getData("疯狂Ajax讲义");
o.out();
// 调用Output接口中定义的默认方法
o.print("孙悟空", "猪八戒", "白骨精");
o.test();
// 创建一个Printer对象，当成Product使用
Product p = new Printer();
System.out.println(p.getProduceTime());
// 所有接口类型的引用变量都可直接赋给Object类型的变量
Object obj = p;
}
}
*************************************************
public class ProcessArray {
public void process(int[] target, Command cmd) {
cmd.process(target);
}
}
复制代码
。。。。。。。。。。。。。。。。
2018-07-03
【04-面向对象(上)】
定义类
•定义类的语法格式:
•[修饰符] class 类名 {….类体…..}
•类体可以由多个属性、方法、构造器组成。
•注意:类的修饰符可以是public、final 或省略这两个。类名只要是合法的标识符.
•一个类里可以包含三种最常见的成员：构造器、属性、方法。
定义属性的格式语法
•[修饰符] 属性类型 属性名 [= 默认值];
定义方法的格式语法
•[修饰符] 方法返回值类型 方法名(形参列表) {….方法体….}
– 方法中的修饰符可以是public ,protected,private,static,final,abstract,其中访问控制符只能出现一
个,abstract ,final 只能出现其一.
–返回值类型可以是基本类型和引用类型,如果无返回值,要用void 来声明
–形参列表,可以由零到多组组成,参数之间用逗号(“,”)隔开.
–static 是一个特殊的关键字,译为”静态”,所有有static 修饰的叫类属性,类方法,类成员.
定义构造器的语法格式
•[修饰符] 构造器名(形参列表) {……}
–修饰符可以是public protected private 构造器必须和类名相同,形参和方法的形参一样.
对象的产生和使用
•创建对象的根本途径就是构造器,所以创建对象通过关键字new 加上对应的构造器即可.
•如果访问权限允许,类里定义的属性和方法可以通过类或实例来调用,
•有static 修饰的访求和属性,既可通过类来调用,也可以通过实例来调用.
对象.引用和指针
•Person p = new Person();,这行代码创建了一个Person 实例,也被称为对象,这个对象被赋给了p变量.
•也就是说引用型变量里存放的仅仅是一个引用,它指向实际的对象.
对象的this 引用
•this 关键字总是指向调用该方法的对象.
–1.构造器中引用该构造器执行初始化的对象
–2.在方法中引用调用该方法的对象
•在方法里的this 指谁调用就指谁
•注: this 不能用在有static 修饰的方法中.
方法的详解
•方法的所属性
–一旦将一个方法定义在一个类里,如果用static 修饰了,这个方法属于这个类,否则属于这个类的对象.
–方法不能独立执行,必须要有调用者.(如:类.方法、对象.方法)
–方法不能独立定义,只能定义在类里.
–方法要么属于一个类,要么属于一个对象
方法的参数传递机制
传递方式只有一种:值传递.
形参长度可变的方法
•如果在定义方法时,在最后一个参数的类型后增加三点…,则表明该形参接受多个参数值,多个参数值被当成数组传
入.
•长度可变的形参只能位于最后一个参数,并一个方法里只能有一个可变长度的参数.
递归
•递归就是在方法中再次调用自己。
•递归一定要向已知方向递归.
方法的重载
•Java 允许在一个类里定义多个同名方法,只要形参列表不同即可.
•所以方法的重载只要满足两个条件(两同一不同)：1.同一个类中,方法名相同；2.形参不同。和返回值类型无关.
所以在调用这些方法时要传入不同的参数值.
成员变量和局部变量
•成员变量指的是在类范围里定义的变量；局部变量指的是在一个方法内定义的变量。
•不管是成员变量还是局部变量都遵守相同的命名规则。
•成员变量分为类属性和实例属性.对于类属性无论通过类还是对象来访问都是访问同一个对象,只要一个对象改变
了类属性,那么其他对象对应的类属性也改变了.成员变量不用显式初始化,只要定义了一个类属性或实例属性,系统
默认进行初始化。
局部变量
•局部变量可分为三种：
–形参
–方法局部变量
–代码块局部变量.
•与成员变量不同的是除了形参外,其他局部变量都必须显式地初始化,
•Java 里允许局部变量和成员变量重名。这样局部变量会覆盖成员变量,这时通过this 来调用实例的属性.
成员变量的初始化
•当类被加载时,类成员就在内存中分配了一块空间。
•当对象被创建时，实例成员就在内存中分配了内存空间。
•实例变量与实例共存亡；类变量与类本身共存亡。
局部变量的运行机制
•局部变量仅在方法内有效。
•当方法执行完成时，局部变量便会自动销毁。
封装
•理解封装：封装是面向对象的三大特征之一。
• 封装包含两方面含义：
–合理隐藏。
–合理暴露。
本文原创作者：pipi-changing
本文原创出处：http://www.cnblogs.com/pipi-changing/
使用访问控制符
•private 私有的。在同一个类里能被访问。
•default 默认的。包访问权限
•protected 受保护的。子类中也能访问
•public 公共的。在任何地方都可以访问
package 和 import
•package 打包格式：package 包名；放在程序开始的顶端。
•包机制的两个方面的保证。1.源文件里要使用package 语句指定包。2.class 文件必须放在对应的路径下。
•import 引入包格式。分为两种：
–非静态导入，导入的是包下所有的类。如：import package.subpackage.*;
–静态导入，导入的是类的静态属性。如：import static package.className.*;
Java 的常用包
•java.lang.*,
•java.util.*,
•java.net.* ,
•java.io.*,
•java.text.*,
•java.sql.*,
•java.awt.*,
•java.swing.*.
使用构造器执行初始化
•构造器最大的用处就是在创建对象时执行初始化，系统会默认的进行初始化。
•如果程序员没有Java 类提供任何构造器，则系统会为这个类提供一个无参的构造器。
•一旦程序员提供了自定义的构造器，遇系统不再提供默认的构造器。
构造器的重载
•构造器的重载和方法的重载一样，都是方法名相同，形参列表不相同。
•在构造器中可通过this来调用另外一个重载的构造器。
继承的特点
•Java通过关键字extends来实现，实现继承的类称为子类，被继承的类称为基类、超类、父类。父类是大类，子
类是小类。
•Java的继承是单继承，每个子类最多只有一个直接父类。
本文原创作者：pipi-changing
本文原创出处：http://www.cnblogs.com/pipi-changing/
继承
•子类继承父类的语法格式如下：
•修饰符 class subclass extends superclass {。。。。。。}
•子类扩展了父类，将可以获得父类的全部属性和方法，但不能获得父类构造器
•Java里的继承都是单继承，也就是只能有一个直接的父类，可以有n个间接父类。
重写父类的方法
•方法的重写要遵循“两同两小一大” 指的是：方法名相同，形参列表相同。返回值类型更小或相同，抛出的异常更
小或相同，访问控制权限要更大。
父类实例的super限定
•通过关键字super 来调用父类的方法或属性。
super调用父类的构造器
•子类构造器总会调用父类构造器。
•如果子类构造器没有显式使用super调用父类构造器；子类构造器默认会调用父类无参数的构造器。
•创建一个子类实例时，总会先调用最顶层父类的构造器。
多态性
•Java 引用变量有两个类型：一个是编译时的类型，一个是运行时的类型，编译时的类型由声明该变量时使用的类
型决定，运行时的类型由实际赋给该变量的对象决定。
•如果编译时类型和支行时的类型不一致，这就有可能出现所谓的多态。
•两个相同类型的引用变量，由于它们实际引用的对象的类型不同，当它们调用同名方式时，可能呈现出多种行为
特征，这就是多态。
引用变量的类型转换
•将一个子类对像赋给父类，这就是向上转型。向上转型是自动的。
•强制类型转换： 类型转换运算符是小括号，语法如下（type）variable；
instanceof运算符
•前一个操作通常是一个引用类型的变量，后一个操作通常是一个类（也可以是接
口）。如果是 返回true， 否返回false。
继承和组合
•使用继承的注意点
•利用组合实现复用：总之，继承要表达的是一种“是（is-a）”的关系，而组合表达的是”有（has-a）“的关系。
本文原创作者：pipi-changing
本文原创出处：http://www.cnblogs.com/pipi-changing/
初始化块
•使用初始化块：初始化块由大括号括起{…}，只能由static修饰。
•初始化块和构造器：初始化块总在构造器之前执行，初始化块不能接受形参。
静态初始化块
•用static修饰的初始化块为静态初始化块，由于是静态的，所以是属于类，当类加载时，就执行静态初始化块 ，
但执行一个子类时，最先执行其最顶层父类的静态初始化，
•初始化块是属于实例 的。只要创建一次对象，初始化块就执行一次。
下面贴出代码：
Dog
DogTest
Person
PersonTest
ReturnThis
StaticAccessNonStatic
ThisInConstructor
Overload
OverloadVarargs
PrimitiveTransferTest
Recursive
ReferenceTransferTest
Varargs
复制代码
public class BlockTest {
public static void main(String[] args) {
{
// 定义一个代码块局部变量a
int a;
// 下面代码将出现错误，因为a变量还未初始化
// System.out.println("代码块局部变量a的值：" + a);
// 为a变量赋初始值，也就是进行初始化
a = 5;
System.out.println("代码块局部变量a的值：" + a);
}
// 下面试图访问的a变量并不存在
// System.out.println(a);
}
// 代码块局部变量a的值：5
}
复制代码
。。。。。。。。。。。。。。。。。。。
2018-07-03
【03-流程控制与数组】
顺序结构
•顺序结构就是程序从上到下一行一行地执行，中间没有任何判断和跳转。
•如果main方法多行代码之间没有任何流程控制，则程序总是从上向下依次执行，排在前面的代码先执行，排在后
面的代码后执行。
分支结构
•Java提供了两种常见的分支控制结构：
–if语句：使用布尔表达式或布尔值作为分支条件来进行分支控制。
–switch语句：用于对多个整型值进行匹配，从而实现分支控制。
if条件语句
•if条件语句的3种形式：
• ▲ if (logic expression) { statements…}
• ▲ if (logic expression) { statements…}
• else { statements…}
• ▲ if (logic expression) { statements…}
• else if (logic expression) { statements…}
• …//可以有0个或多个else if 语句
• else { statements…} //最后的else语句也可以省略
•注意：if、else、else if 后条件执行体要么是一个花括号括起来的语句块，则这个语句块整体作为条件执行体；
要么是以分号为结束符的一行语句，甚至可能是一个空语句（空语句就是一个分号）。
If语句常见的错误
•如果if、else、else if后的执行体只有一行语句时，则可以省略花括号，但我们最好不要省略花括号，因为保留花
括号会有更好的可读性，且还可以减少发生错误的可能。
•对于if 语句，还有一个很容易出现的逻辑错误，这个逻辑错误并不属于语法问题，但引起错误的可能性更大。如
后面程序TestIfError.java我们想打印的是中年人，但打印出来的结果是青年人。
• 对于任何的if else 语句，表面上看起来else后没有任何条件，或者else if后只有一个条件，但这不是真相：因为
else的含义是“否则”，else本身就是一个条件！else 的隐含条件就是对前面条件取反。
switch分支语句
•可以省略case后代码块的花括号
◆使用break;语句，防止case穿透
◆default可以省略，但不推荐省略
◆switch语句中控制表达式的类型只能是byte、short、char、int、String（JDK7新增）和枚举
Switch语句容易导致的错误
•switch语句后的expression表达式的数据类型只能是byte、short、char、int、String类型和枚举；
•小心省略了case后代码块的break;时所引入的陷阱。
循环结构
•Java支持3种基本的循环语句：
–while 循环语句
–do while 循环语句
– for 循环语句
while & do while 循环语句
★ while 循环的语法格式如下：
[init_statements]
while (test_expression)
{ statements;
[iteration_statements]
}
★ 执行过程：先判断逻辑表达式的值，若为true
则执行其后面的语句，然后再次判断条件并反复
执行，直到条件不成立为止。
★ do while 循环的语法格式如下：
[init_statements]
do
{ statements;
[iteration_statements]
}while (test_expression);
※注意：do while 循环的循环条件必须有一个分
号，这个分号表明循环结束。
★ 执行过程：先执行语句，再判断逻辑表达式的
值，若为true，再执行语句，否则结束循环
控制循环条件
•使用循环时，一定要保证循环条件有变成false的时候，如果循环条件永远为true，那就是死循环。使用while循
环时还有一个陷阱，while循环条件后紧跟一个分号。
•do while 循环语句里，即使test_expression循环条件的值开始是假，do while循环也会执行循环体。因此，
do while循环的循环体至少执行一次。
本文原创作者：pipi-changing
本文原创出处：http://www.cnblogs.com/pipi-changing/
for 循环语句
•for ([inint_statements] ; [test_expression] ; [iteration_statements]){ statements }
•★ 执行过程：首先计算表达式1，即init_statements，接着执行表达式2，即test_expression，若表达式2的
值为true，则执行语句（statements），接着执行表达式3，即iteration_statements，再判断表达式2的值；
依次重复下去，直到表达式的值=false，则结束for循环。因此，for循环的循环条件（表达式2）比循环体（语
句）要多执行一次。
•注意：for循环的循环迭代语句并没有与循环体放在一起，因此即使在执行循环体时遇到continue语句结束本次
循环，循环迭代语句一样会得到执行。
for循环指定多个初始化语句
•for 循环允许同时指定多个初始化语句，循环条件也可以是一个包含逻辑运算符的表达式。但只能有一个声明语
句，因此如果需要在初始化表达式中声明多个变量，那么这些变量应该有相同的数据类型。
•初学者使用for循环时也容易犯一个错误，他们以为只要在for后的括号内控制了循环循环迭代语句就万无一失，
但实际情况则不是这样的。
for循环的分号
•for 循环圆括号中只有两个分号是必须的，初始化语句、循环条件、迭代语句部分都可以省略，如果省略了循环
条件，则这个循环条件默认是true，将会产生一个死循环。
•使用for循环时，还可以把初始化条件定义在循环体之外，把循环迭代语句放在循环体内，这种做法将非常类似前
面的while循环。
嵌套循环
•各种基本类型的循环都可以作为外层循环，各种基本类型的循环也可以作为内层循环。
•假设外层循环的循环次数为n次，内层循环的循环次数为m次，那么内层循环的循环体实际上需要执行n*m次。
•实际上，嵌套循环不仅可以是两层嵌套，还可以是三层嵌套，四层嵌套……
break语句
•break用于完全结束一个循环，跳出循环体。不管是哪种循环，一旦在循环体中遇到break，系统将完全结束循
环，开始执行循环之后的代码。
•break不仅可以结束其所在的循环，还可结束其外层循环。此时需要在break后紧跟一个标签，这个标签用于标
识一个外层循环。Java中的标签就是一个紧跟着英文冒号（:）的标识符。且它必须放在循环语句之前才有作用。
continue 语句
•continue的功能和break有点类似，区别是continue只是中止本次循环，接着开始下一次循环。而break则是
完全中止循环。
return语句
• return关键字并不是专门用于跳出循环的，return的功能是结束一个方法。
•一旦在循环体内执行到一个return语句，return语句将会结束该方法，循环自然也随之结束。与continue和
break不同的是，return直接结束整个方法，不管这个return处于多少层循环之内。
数组类型
•在任何已有类型后加上方括号[ ]，又变成一种新类型，这种类型统称为数组类型，所有的数组类型又称为引用类
型，所以又称引用类型。
•Java的数组要求所有数组元素具有相同的数据类型。因此，在一个数组中，数组元素的类型是唯一的，即一个数
组里只能存储一种数据类型的数据，而不能存储多种数据类型的数据。
•一旦数组的初始化完成，数组在内存中所占的空间将被固定下来，因此数组的长度将不可改变。即使把某个数组
元素的数据清空，但它所占的空间依然被保留，依然属于该数组，数组的长度依然不变。
•Java的数组既可以存储基本类型的数据，也可以存储引用类型的数据。
•值得指出的是：数组也是一种数据类型，它本身是一种引用类型。
定义数组
•Java语言支持两种语法格式来定义数组：
–type[ ] arrayName;
–type arrayName[ ];
•对于这两种语法格式，一般推荐使用第一种格式。因为第一种格式不仅具有更好的语意，也具有更好的可读性。
•数组是一种引用类型的变量，因此使用它定义一个变量时，仅仅表示定义了一个引用变量（也就是定义了一个指
针），这个引用变量还未指向任何有效的内存，因此定义数组时不能指定数组的长度。
•※注意：定义数组时不能指定数组的长度。
数组的初始化
•静态初始化：初始化时由程序员显式指定每个数组的初始值，由系统决定需要的数组长度。
•动态初始化：初始化时程序员指定数组长度，由系统为数组元素分配初始值
动态初始化
•arrayName = new type[ length];
在上面的语法中，需要指定一个int整型的length参数，这个参数指定了数组的长度，也就是可以容纳数组元素的
个数。
使用数组
•数组最常用的用法就是访问数组元素，包括对数组元素赋值和访问数组元素的值，访问数组元素是通过在数组引用变
量后紧跟一个方括号（[ ]），方括号里是数组元素的索引值。
•Java语言的数组索引是从0开始的，也就是说，第一个数组元素的索引值为0，最后一个数组元素的索引为数组长度
减1。
•如果访问数组元素进指定的索引小于0，或者大于等于数组的长度，编译程序不会出现任何错误，但运行时出现异
常：java.lang.ArrayIndexOutOfBoundsException:2（数组索引越界异常），在这个异常提示信息后有一个int
整数，这个整数就是程序员试图访问的数组索引。
•所有数组都提供了一个length属性，通过这个属性可以访问到数组的长度，一旦获得了数组的长度后，就可以通过循
环来遍历该数组的每个数组元素。
JDK1.5 提供了foreach循环
•从JDK1.5 之后，Java提供了一种更简单的循环：foreach循环，这种循环遍历数组和集合更加简洁。使用
foreach循环遍历数组和集合元素时，无须获得数组和集合长度，无须根据索引来访问数组元素和集合元素，
foreach循环自动遍历数组和集合的每个元素。
•当使用foreach循环来迭代输出数组元素或集合时，通常不要对循环变量进行赋值，虽然这种赋值在语法上是允
许的，但没有太大的意义，而且极容易引起错误。
深入数组
•数组元素和数组变量在内存里是分开存放的。
实际的数组元素是存储在堆（heap）内存中；数组引用变量是一个引用类型的变量，被存储在栈（stack）内存
中。
•如果堆内存中数组不再有任何引用变量指向自己，则这个数组将成为垃圾，该数组所占的内存将会被系统的垃圾
回收机制回收。因此，为了让垃圾回收机制回收一个数组所占的内存空间，则可以将该数组变量赋为null，也就切
断了数组引用变量和实际数组之间的引用关系，实际数组也就成了垃圾。
数组长度不可变
•只要类型相互兼容，可以让一个数组变量指向另一个实际的数组，这种操作会产生数组的长度可变的错觉。
•但由于数组变量整体赋值导致的数组的长度可以改变，只是一个假相。
基本类型数组的初始化
•对于基本类型数组而言，数组元素的值直接存储在对应的数组元素中，因此，初始化数组时，先为该数组分配内
存空间，然后直接将数组元素的值存入对应数组元素中，
TestPrimitiveArray
引用类型数组的初始化
引用类型数组的数组元素是引用，因此情况变得更加复杂：每个数组元素里存储的还是引用，它指向另一块内存，
这块内存里存储了有效数据。
没有多维数组
•Java语言提供了多维数组的语法，但多维数组实质上还是一维数组。
Java语言里的数组类型是引用类型，因此，数组变量其实是一个引用，这个引用指向真实的数组内存。数组元素
的类型也可以是引用，如果数组元素的引用再次指向真实的数组内存，这种情形看上去很像多维数组。
•定义二维数组的语法：
•type[ ] [ ] arrName;
TestTwoDimension
我们可以得到一个结论：
二维数组是一维数组，其数组元素是一维数组；三维数组也是一维数组，其数组元素是二维数组；四维数组还是一维数
组，其数组元素是三维数组……从这个角度来看，Java语言里没有多维数组。
2018-07-03
【02-数据类型与运算符】
注释
• 单行注释 用双斜线 ”//” 表示
• 多行注释 用 /*------------------*/ 表示
• 文档注释 用 /**-----------------*/ 表示
文档注释与javadoc
•文档注释还可以通过javadoc 命令来生成API文档
•格式: javadoc –d apidoc 源文件名
–其中-d path指定存放API文档的路径。
•API 文档包括三个区域分别是:包区域,类区域,详细说明区域
注: 如果要出现包区域,要让不同类处于不同的包下面才会出现包区域。
标识符和关键字
•分隔符：常见的分隔符有分号; 花括号{} 方括号[ ] 圆括号() 空格 圆点 .
–在 Java 语言中每一条语句的结束用分号表示;
•标识符的规则：由字母,数字,下划线_,美元$组成,但数字不能开头.
•标识符不能是java的关键字和保留字,但中间可以包含标识符，不能包含空格。
•Java 的关键字加上goto const true false null 一共有53个关键字和保留字，都不能作为Java的标识符。
标识符举例
–abc_xyz √
–HelloWorld √
–abc$ √
–$中文 √
–_abc 对 √
–xyz#abc ×
–abc1 √
–1abc ×
数据类型的分类
•Java语言是一个强类型语言。
–所有变量，必须先声明类型，再使用。
–指定类型的变量，只能装对应的类型的数据。什么样的瓶子装什么样的酒。
•Java 语言支持的类型分为两大类: 基本数据类型和引用类型
–基本数据类型包括八大数据类型。
–引用类型包括数组、类、接口。
变量
•变量就是用来记录数据的。
•计算机内存里数据就需要通过变量来访问它。
•通俗一点，你可以把变量理解成容器，它可以装数据。
使用Scanner获取键盘输入
•使用Scanner类可以很方面地获取用户的键盘输入，Scanner是一个基于正则表达式的文本扫描器，它可以从文
件、输入流、字符串中解析出基本类型值和字符串值。Scanner类提供了多个构造器，不同的构造器可接受文件、输
入流、字符串作为数据源，用于从文件、输入流、字符串中解析数据。
•Scanner主要提供了两个方法来扫描输入：
–hasNextXxx()：是否还有下一个输入项，其中Xxx可以是Int、Long等代表基本数据类型的字符串。如果
需要判断是否包含下一个字符串，则可以省略Xxx。
–nextXxx()：获取下一个输入项。Xxx的含义与前一个方法中Xxx相同。
基本数据类型
•Java 的基本数据类型可以分为两大类: boolean 类型 和 数值类型.
•而数值类型又可以分为整型和浮点型
–整型包括:byte short int long（广义的整型包括char型）
–在内存中各占:1,2,4,8个字节, 各有各的取值范围,略记一下。
•在定义long 类型时 必须在数字后面加L,
•整数常量有三种表示方式: 十进制,八进制(以0开头),十六进制(以0x开头), 二进制（以OB开头—jdk1.7）
•在java 语言中,运算过程中,整型类型默认为 int 类型
•什么样的类型的变量 只能存放什么样类型的值
浮点型
•浮点型 包括 : float 和 double 型 两种。他们分别占有4个字节和8个字节,但他们远远比int 和 long 的 4 和 8
个字节大的多
•Java 语言的浮点数有两种表示方式：十进制数形式,浮点数必须包含小数,否则系统将认为是一个int 型 如: 8.0
不能省略为: 8
•科学计数法形式：
–注: 只有浮点数才有科学计数法,,
•Java 语言的浮点数默认是double 型,,如果要表示float 型 必须在数字后面加 f(如：1.3f),
•Java 的三个特殊的浮点数值:正无穷大,负无穷大和非数
•所有的正无穷大都是相等,负无穷大都是相等,,而非数不与任何数值相等,与自己也不相等,只有浮点数除0 才可以
得到这三个数,整数除0将报错;
2018-07-03
【01-结构化程序设计】
结构化程序设计简介
•结构化程序设计方法主张按功能来分析系统需求，其主要原则可概括为自顶向下，逐步求精，模块化等。结构化
程序设计首先采用结构化分析（Structrued Analysis，即SA）方法对系统进行需求分析，然后使用结构化设计
（Structrued Design，即SD）方法对系统进行概要设计、详细设计，最后采用结构化编程（Structrued
Program，即SP）方式来实现系统。使用这种SA、SD和SP的方式可以较好的保证软件系统的开发进度和质量。
•因为结构化程序设计方法主张按功能把软件系统逐步细分，因此这种方法也被成为面向功能的程序设计方法；结
构化程序设计的每个功能都负责对数据进行一次处理，每个功能都接受一些数据，处理完后输出一些数据，这种处理方
式也被称为面向数据流的处理方式。
结构化程序设计的局限性
•设计不够直观，与人类习惯思维不一致。采用结构化程序分析、设计时，开发者需要将客观世界模型分解成一个
一个功能，每个功能用以完成一定的数据处理。
•适应性差，可扩展性不强。由于结构化设计采用自顶而下的设计方式，所以当用户的需求发生改变，或需要修改
现有的实现方式时都需要自顶而下地修改模块结构，这种方式的维护成本相当大。
程序的三种结构
•结构化程序设计非常强调实现某个功能的算法，而算法的实现过程是由一系列操作组成的，这些操作之间的执行
次序就是程序的控制结构。1996年，计算机科学家Bohm和Jacopini证明了这样的事实：任何简单或复杂的算法都可
以由三种结构组成
–顺序结构
–选择结构
–循环结构这
•这三种结构就被称为程序设计的三种基本结构，也是结构化程序设计必须采用的结构
顺序结构
。。。。。。。。。。。。。。
2018-07-03
使用 Eclipse 调试 Java 程序的技巧
断点视图 ： 条件断点】
如果你只对应用中的某部分感兴趣的话，这个功能非常有用。例如，如果你要在第13次循环的时候检查程
序，或者在一个抽象父类中调试某些功能，而你只关注其 中一个具体的实现。你可以在断点视图中设置条件，
或者通过代码旁边的蓝色断点标记的右键菜单（"Breakpoint Properties"）设置。你可以在条件代码片段为
true的时候暂停程序，或者当代码片段的值改变的时候挂起程序。
顾名思义就是一个有一定条件的断点，只有满足了用户设置的条件，代码才会在运行到断点处时停止。
在断点处点击鼠标右键，选择最后一个"Breakpoint Properties"
断点的属性界面及各个选项的意思如下图，
2018-06-27
抽象类和接口的区别
抽象类和接口的区别
【概述】
一个软件设计的好坏，我想很大程度上取决于它的整体架构，
而这个整体架构其实就是你对整个宏观商业业务的抽象框架，当代表业务逻辑的高层抽象层结构 合理时，
你底层的具体实现需要考虑的就仅仅是一些算法和一些具体的业务实现了。
当你需要再开发另一个相近的项目时，你以前的抽象层说不定还可以再次利用 。
面向对象的设计，复用的重点其实应该是抽象层的复用，而不是具体某一个代码块的复用。
在 面向对象的概念中，我们知道所有的对象都是通过类来描绘的，但是反过来却不是这样。
并不是 所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，
这样的类就是抽象类。抽象类往往用来表征我们在对问题领域进行分析、 设计中得出的抽象概念，
是对一系列看上去不同，但是本质上相同的具体概念的抽象。
比如：如果我们进行一个图形编辑软件的开发，就会发现问题领域存在着圆、 三角形这样一些具体概念，
它们是不同的，但是它们又都属于形状这样一个概念，形状这个概念在问题领域是不存在的，
它就是一个抽象概念。正是因为抽象的概念 在问题领域没有对应的具体概念，
所以用以表征抽象概念的抽象类是不能够实例化的。
在面向对象领域，抽象类主要用来进行类型隐藏。 我们可以构造出一个固定的一组行为的抽象描 述，
但是这组行为却能够有任意个可能的具体实现方式。这个抽象描述就是抽象类，
对于面向对象编程来说，抽象是它的一大特征之一。在Java中，可以通过两种形式来体现OOP（Object Oriented Programming，OOP，面向对象程序设计）的抽象：接口和抽象类。
这两者有太多相似的地方，又有太多不同的地方。很多人在初学的时候会以为它们可以随意互换使用，但是实际则不然。
今天我们就一起来学习一下Java中的接口和抽象类。
【抽象类】
在了解抽象类之前，先来了解一下抽象方法。
抽象方法是一种特殊的方法：它只有声明，而没有具体的实现。抽象方法的声明格式为：
abstract void fun();
抽象方法必须用abstract关键字进行修饰。如果一个类含有抽象方法，则称这个类为抽象类，
抽象类必须在类前用abstract关键字修饰。因为抽象类中含有无具体实现的方法，所以不能用抽象类创建对象。
抽象类不一定必须含有抽象方法。比如：
复制代码
public abstract class Dog {
//普通方法
void bark() {
}
//抽象方法
abstract void Play();
}
复制代码
[public] abstract class ClassName {
abstract void fun();
}
从这里可以看出，抽象类就是为了继承而存在的，如果你定义了一个抽象类，却不去继承它，
那么等于白白创建了这个抽象类，因为你不能用它来做任何事情。对于一个父类，
如果它的某个方法在父类中实现出来没有任何意义，必须根据子类的实际需求来进行不同的实现，
那么就可以将这个方法声明为abstract方法，此时这个类也就成为abstract类了。
包含抽象方法的类称为抽象类，但并不意味着抽象类中只能有抽象方法，它和普通类一样，
同样可以拥有成员变量和普通的成员方法。注意，抽象类和普通类的主要有三点区别：
1）抽象方法必须为public或者protected（因为如果为private，则不能被子类继承，子类便无法实现该方法），
缺省情况下默认为public。
2018-06-27
重载与覆写/重写的区别
重载与覆写/重写的区别
区别
重载
覆写
1
单词
OverLoading
Override
2
概念
方法名称相同，参数的类型或个数不同
方法名称相同，参数的类型或个数相
同，返回值类型相同
3
范围
发生在一个类之中
发生在类的继承关系中
4
权限
一个类中所重载多个方法可以不同的权限
被子类所覆写的方法不能拥有比父类更严格
的访问控制权限
重载可以改变返回值类型，但是这样做没有任何的意义，
可是对于覆写而言，绝对不能修改返回值类型，但是在子类中所覆写的方法应该可以继续进行重载。
重载(Overloading)
（1） 方法重载是让类以统一的方式处理不同类型数据的一种手段。多个同名函数同时存在，具有不同的参数个数/类型。
重载Overloading是一个类中多态性的一种表现。
（2） Java的方法重载，就是在类中可以创建多个方法，它们具有相同的名字，但具有不同的参数和不同的定义。
调用方法时通过传递给它们的不同参数个数和参数类型来决定具体使用哪个方法, 这就是多态性。
（3） 重载的时候，方法名要一样，但是参数类型和个数不一样，返回值类型可以相同也可以不相同。
无法以返回值类型作为重载函数的区分标准。
复制代码
/**
* 1. 方法重载只可以通过方法名和方法参数来区别，即“方法签名”
* @return
* @throws NumberFormatException
*/
public int getSides(Object obj) throws NumberFormatException {
return 1;
}
/**
* 2. 不能通过访问权限，返回类型，异常列表进行重载
*
* 下面方式错误！
*/
private Object getSides() throws NumberFormatException, Exception {
return 1;
}
/**
* 3. 方法异常类型和数目不会对重载造成影响。
* 下面方式错误！
*/
public int getSides() throws NumberFormatException, IndexOutOfBoundsException, Exception {
}
复制代码
重写（Overriding）
（1） 父类与子类之间的多态性，对父类的函数进行重新定义。
如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Overriding)。
在Java中，子类可继承父类中的方法，而不需要重新编写相同的方法。
但有时子类并不想原封不动地继承父类的方法，而是想作一定的修改，这就需要采用方法的重写。
方法重写又称方法覆盖。
（2）若子类中的方法与父类中的某一方法具有相同的方法名、返回类型和参数表，则新方法将覆盖原有的方法。
如需父类中原有的方法，可使用super关键字，该关键字引用了当前类的父类。
（3）子类函数的访问修饰权限不能小于父类的；
多态性是面向对象编程的一种特性，和方法无关，
简单说，就是同样的一个方法能够根据输入数据的不同，做出不同的处理，
即方法的重载——有不同的参数列表（静态多态性）
而当子类继承自父类的相同方法，输入数据一样，但要做出有别于父类的响应时，你就要覆盖父类方法，
即在子类中重写该方法——相同参数，不同实现（动态多态性）
复制代码
public class Base {
void test(int i) {
System.out.print(i);
}
void test(byte b) {
System.out.print(b);
}
}
public class Dog extends Base {
void test(int i) {
i++;
System.out.println(i);
}
public static void main(String[] agrs) {
Base b = new Dog();
b.test(0);
b.test((byte) 0);
}
}
复制代码
这时的输出结果是1 0，这是运行时动态绑定的结果。
简单说来重写就是子类对父类（层级上）中非私有成员方法的重新功能定义。
复制代码
// begin
/**
* 1. 重写方法必须和被重写方法的“方法签名”一致，即方法名+参数必须相同
*/
public int getSides() {
return 3;
}
// end
// begin
/**
* 1. 重写方法访问修饰符一定要大于被重写方法访问修饰符
* （public > protected > default > private）
*
* 原因：
* 2. 有一个可以装1升水的瓶子；你需要用另一个瓶子去继承它，
那你觉得你能用一个半升谁的瓶子继承他吗？
*/
/**
* @return
* 本方法重写方式错误
*/
// protected int getSides() {
// return 3;
// }
/**
* 对父类Shape中getSide方法进行重写，实现多态
* @return
*/
public int getSides() {
return 3;
}
// end
// begin
/**
* 3. 重写和被重写方法返回值必须相同
* 此方法错误
*/
// public double getSides() {
// return 3d;
// }
// end
// begin
/**
* 4. 重写方法抛出的异常必须和被重写方法抛出异常一致，或者是其子类
* 详细见：overrideexception包中例子
*/
public int getSides() throws NullPointerException {
return 3;
}
// end
/**
* 5. 父类中private方法不能被子类重写，因为private只有父类本类可见。
*/
/**
* 6. 静态方法不存在重写概念，重写是面向对象特性，静态方法是类方法，用类名直接访问。
*/
复制代码
2018-06-27
Java中this与super的区别
Java中this与super的区别
this&super;
什么是this,this是自身的一个对象，代表对象本身，可以理解为：指向对象本身的一个指针。
Java关键字this只能用于方法的方法体内。当一个对象创建后，
Java虚拟机（JVM）就会给这个对象分配一个引用自身的指针，这个指针的名字就是this。
当你想要引用当前对象的某种东西，比如当前对象的某个方法，或当前对象的某个成员，
你便可以利用this来实现这个目的。要注意的是this只能在类中的非静态方法中使用，
静态方法和静态的代码块中绝对不能出现this。this也可作为构造函数来使用。在后面可以看到
而什么是super，可以理解为是指向自己超（父）类对象的一个指针，
而这个超类指的是离自己最近的一个父类。super的作用同样是可以作为构造函数使用，
或者是获取被局部变量屏蔽掉的父类对象的某个同名变量的值。
super关键和this作用类似，是被屏蔽的成员变量或者成员方法或变为可见，
或者说用来引用被屏蔽的成员变量和成员成员方法。
作为构造函数使用
super（参数）：调用父类中的某一个构造函数（应该为构造函数中的第一条语句）。
this（参数）：调用本类中另一种形式的构造函数（应该为构造函数中的第一条语句）。
要记住的几个关键点是：
在构造方法中this与super不能共存；其次有this或super出现的地方必须是构造方法的第1句；
静态方法，也就是类方法中不能有this和super关键字
1. 子类的构造函数如果要引用super的话，必须把super放在函数的首位.
复制代码
class Base {
Base() {
System.out.println("Base");
}
}
public class Checket extends Base {
Checket() {
super();// 调用父类的构造方法，一定要放在方法的首个语句
System.out.println("Checket");
}
public static void main(String argv[]) {
Checket c = new Checket();
}
}
复制代码
结果：
Base
Checket
如果想用super继承父类构造的方法，但是没有放在第一行的话，那么在super之前的语句，
肯定是为了满足自己想要完成某些行为的语句，但是又用了super继承父类的构造方法。
那么以前所做的修改就都回到以前了，就是说又成了父类的构造方法了。
2． 在Java中，有时还会遇到子类中的成员变量或方法与超类（有时也称父类）
中的成员变量或方法同名。因为子类中的成员变量或方法名优先级高，
所以子类中的同名成员变量或方法就隐藏了超类的成员变量或方法，
但是我们如果想要使用超类中的这个成员变量或方法，就需要用到super.
。。。。。。。。。。。。。
2018-06-27
函数、内存、一维数组、二维数组
函数的定义
什么是函数？
•函数就是定义在类中的具有特定功能的一段独立小程序。
•函数也称为方法。
函数的格式：
•修饰符 返回值类型 函数名(参数类型 形式参数1，参数类型 形式参数2，...)
{
执行语句;
return 返回值;
}
返回值类型：函数运行后的结果的数据类型。
参数类型：是形式参数的数据类型。
形式参数：是一个变量，用于存储调用函数时传递给函数的实际参数。
实际参数：传递给形式参数的具体数值。
return：用于结束函数。
返回值：该函数运算后的结果，该结果会返回给调用者。
函数的特点
定义函数可以将功能代码进行封装
便于对该功能进行复用
函数只有被调用才会被执行
函数的出现提高了代码的复用性
对于函数没有具体返回值的情况，返回值类型用关键字void表示，
那么该函数中的return语句如果在最后一行可以省略不写。
注意：
•函数中只能调用函数，不可以在函数内部定义函数。
•定义函数时，函数的结果应该返回给调用者，交由调用者处理。
函数的应用
两个明确
•明确要定义的功能最后的结果是什么？
•明确在定义该功能的过程中，是否需要未知内容参与运算
示例：
•需求：定义一个功能，可以实现两个整数的加法运算。
•分析：
•该功能的运算结果是什么？两个数的和，也是一个整数(int)
•在实现该功能的过程中是否有未知内容参与运算？加数和被加数是不确定的。(两个参数int，int)
•代码：
int getSum(int x,int y)
{
return x+y;
}
函数的重载(overload)
重载的概念
在同一个类中，允许存在一个以上的同名函数，只要它们的参数个数或者参数类型不同即可。
重载的特点：
与返回值类型无关，只看参数列表。
重载的好处：
方便于阅读，优化了程序设计。
重载示例：
//返回两个整数的和
int add(int x,int y){return x+y;}
//返回三个整数的和
int add(int x,int y,int z){return x+y+z;}
//返回两个小数的和
double add(double x,double y){return x+y;}
函数的功能一样，仅仅是参与运算的未知内容不同时，
可以定义多函数，却使用统一函数名称，这样方便阅读。
在调用时，虚拟机通过参数列表的不同来区分同名函数。
数组
数组的定义
概念
同一种类型数据的集合。其实数组就是一个容器。
数组的好处
可以自动给数组中的元素从0开始编号，方便操作这些元素。
格式1：
元素类型[] 数组名 = new 元素类型[元素个数或数组长度];
示例：int[] arr = new int[5];
格式2：
元素类型[] 数组名 = new 元素类型[]{元素，元素，……};
int[] arr = new int[]{3,5,1,7};
int[] arr = {3,5,1,7};
数组内存结构
内存结构
Java程序在运行时，需要在内存中的分配空间。为了提高运算效率，有对空间进行了不同区域的划分，因
为每一片区域都有特定的处理数据方式和内存管理方式。
栈内存
用于存储局部变量，当数据使用完，所占空间会自动释放。
堆内存
数组和对象，通过new建立的实例都存放在堆内存中。
每一个实体都有内存地址值
实体中的变量都有默认初始化值
实体不在被使用，会在不确定的时间内被垃圾回收器回收
方法区，本地方法区，寄存器
数组操作常见问题
数组脚标越界异常(ArrayIndexOutOfBoundsException)
int[] arr = new int[2];
System.out.println(arr[3]);
访问到了数组中的不存在的脚标时发生。
空指针异常(NullPointerException)
int[] arr = null;
System.out.println(arr[0]);
arr引用没有指向实体，却在操作实体中的元素时。
2018-06-27
Java 关键字、标识符、注释、常量与变量、数据类型，算术、赋值、比较、逻辑、位、三元运算符和流程控制、break、continue
常量表示不能改变的数值。
Java中常量的分类：
1，整数常量。所有整数
2，小数常量。所有小数
3，布尔(boolean)型常量。较为特有，只有两个数值。true false。
4，字符常量。将一个数字字母或者符号用单引号( ' ' )标识。
5，字符串常量。将一个或者多个字符用双引号(“ ”)标识。
6，null常量。只有一个数值就是:null.
对于整数：有四种表现形式。
•二进制：0,1 ，满2进1.
•八进制：0-7 ，满8进1. 用0开头表示。
•十进制：0-9 ，满10进1.
•十六进制：0-9，A-F，满16进1. 用0x开头表示。
进制的基本转换
•十进制 二进制 互转
•十进制转成二进制 除以2取余数
•二进制转成十进制 乘以2的幂数
•十进制 八进制 互转
•十进制 十六进制 互转
•负数的二进制表现形式
对应的正数二进制取反加1
变量的概念：
•内存中的一个存储区域
•该区域有自己的名称（变量名）和类型（数据类型）
•该区域的数据可以在同一类型范围内不断变化
为什么要定义变量：
•用来不断的存放同一类型的常量，并可以重复使用
使用变量注意：
•变量的作用范围（一对{}之间有效）
•初始化值
定义变量的格式：
•数据类型 变量名 = 初始化值；
•注：格式是固定的，记住格式，以不变应万变。
理解：变量就如同数学中的未知数。
变量字节大小及有效取值范围
byte占用一个字节，数字大小为-27—27-1
short占用两个字节，数字大小为-215—215-1
int占用四个字节，数字大小为-231—231-1
long占用八个字节，数字大小为-263—263-1
float占用四个字节，数字大小为1.4E-45~3.4E+38 , -1.4E-45~-3.4E+38 。
用二进制的指数形式表示一个浮点数的格式，如：101*22 , 101*2-3
double占用八个字节，数字大小为4.9E-324~1.7E+308, -4.9E-324~-1.7E+308 。
char占两个字节，数字大小为0———216-1，是unicode编码。
字符的本来面目，我们为什么可以直接将一个数字赋给字符变量。
Boolean占一个字节，其取值只有两个，true和false。
等等 详细介绍用法
2018-06-27
DOS命令大全
e: 进入e盘
dir(directory):目录 查看当前文件夹下的所有目录
cd(change directory):进入到哪里去
cd.. 是返回上一级菜单
cd\ 是直接返回到当前根目录
cd jdk* 进入到jdk目录，*表示后面的所有内容，如果同时有多个文件，则进入第 一个文件
mk(make directory):创建目录
rd(remove directory):删除目录（文件夹）
rd命令是：删除文件夹，如果该文件夹不是空的，则要先删除文件夹里面的内容，才能删除该文件夹，从里到外删除
del(delete):删除文件（只能删除文件，不能删除文件夹），想要删除目录下的所有文件，del * 即可！ * 即为通配符
exit 退出
查找所有命令：help
查找具体某个命令的用法：help 命令 例如：help cd 。。。。。。。。。。。。等
2018-06-27
微信公众号零基础开发视频--JS-SDK多媒体接口和其他接口
微信公众号零基础开发视频--JS-SDK多媒体接口和其他接口，零基础视频开发介绍
对应视频请下载对应连接，微信公众号开发视频（全）
2018-06-01
微信公众号零基础开发视频--JS-SDK的基础接口和分享接口
微信公众号零基础开发视频--JS-SDK的基础接口和分享接口，零基础视频开发介绍
对应视频请下载对应连接，微信公众号开发视频（全）
2018-06-01
空空如也
TA创建的收藏夹 TA关注的收藏夹
TA关注的人