1.JDK和JRE的区别
2.final修饰的作用
3.多态
4.default的含义
5.java中重载与重写的区别
6.键盘事件类KeyListener,KeyEvent
8.随机产生26个英文字母
9. android inflater用法
10.android:gravity与android:layout_gravity
11.android:paddingLeft、android:layout_marginLeft 11
12.进度条变化函数... 11
14.不要标题栏... 12
15.构造方法作用... 12
1.JDK和JRE的区别
很多程序员已经干了一段时间java了依然不明白jdk与jre的区别。
1.JDK
就是Java Development Kit.简单的说JDK是面向开发人员使用的SDK，它提供了Java的开发环境和运行环境。SDK是Software
Development Kit 一般指软件开发包，可以包括函数库、编译程序等。
2.JRE
是Java Runtime Enviroment是指Java的运行环境，是面向Java程序的使用者，而不是开发者。
3.如果安装了JDK，会发同你的电脑有两套JRE，一套位于\jre 另外一套位于 C:\Program Files\Java\jre1.5.0_15 目录下，后面这套比前面那套少了Server端的Java虚拟机，不过直接将前面那套的Server端Java虚拟机复制过来就行了。而且在安装JDK可以选择是否安装这个位于 C:\Program Files\Java 目录下的JRE。如果你只安装JRE，而不是JDK，那么只会在C:\Program Files\Java 目录下安装唯一的一套JRE。
4.JRE的地位就象一台PC机一样，我们写好的Win32应用程序需要操作系统帮我们运行，同样的，我们编写的Java程序也必须要JRE才能运行。所以当你装完JDK后，如果分别在硬盘上的两个不同地方安装了两套JRE，那么你可以想象你的电脑有两台虚拟的Java PC机，都具有运行Java程序的功能。所以我们可以说，只要你的电脑安装了JRE，就可以正确运行Java应用程序。
5、为什么Sun要让JDK安装两套相同的JRE？这是因为JDK里面有很多用Java所编写的开发工具（如javac.exe、jar.exe等），而且都放置在 \lib\tools.jar 里。从下面例子可以看出，先将tools.jar改名为tools1.jar，然后运行javac.exe，显示如下结果： Exception in thread "main"
java.lang.NoClassDefFoundError: com/sun/tools/javac /Main 这个意思是说，你输入javac.exe与输入 java
-cp c:\jdk\lib\tools.jar com.sun.tools.javac.Main 是一样的，会得到相同的结果。从这里我们可以证明javac.exe只是一个包装器（Wrapper），而制作的目的是为了让开发者免于输入太长的指命。而且可以发现\lib目录下的程序都很小，不大于2 9K，从这里我们可以得出一个结论。就是JDK里的工具几乎是用Java所编写，所以也是Java应用程序，因此要使用JDK所附的工具来开发Java程序，也必须要自行附一套JRE才行，所以位于C:\Program Files\Java目录下的那套JRE就是用来运行一般Java程序用的。
6、如果一台电脑安装两套以上的JRE，谁来决定呢？这个重大任务就落在java.exe身上。Java.exe的工作就是找到合适的JRE来运行Java程序。 Java.exe依照底下的顺序来查找JRE：自己的目录下有没有JRE；父目录有没有JRE；查询注册表： [HKEY_LOCAL_MACHINE\SOFTWARE\JavaSoft\Java Runtime Environment] 所以java.exe的运行结果与你的电脑里面哪个JRE被执行有很大的关系。
ADD
：（小小结）
1.JVM -- java virtual machineJVM
就是我们常说的java虚拟机，它是整个java实现跨平台的最核心的部分，所有的java程序会首先被编译为.class的类文件，这种类文件可以在虚拟机上执行，也就是说class并不直接与机器的操作系统相对应，而是经过虚拟机间接与操作系统交互，由虚拟机将程序解释给本地系统执行。
2.JRE -- java runtime environmentJRE是指java运行环境。光有JVM还不能成class的执行，因为在解释class的时候JVM需要调用解释所需要的类库lib。在JDK的安装目录里你可以找到jre目录，里面有两个文件夹bin和lib,在这里可以认为bin里的就是jvm，lib中则是jvm工作所需要的类库，而jvm和 lib和起来就称为jre。所以，在你写完java程序编译成.class之后，你可以把这个.class文件和jre一起打包发给朋友，这样你的朋友就可以运行你写程序了。（jre里有运行.class的java.exe）
3.JDK -- java development kitJDK是java开发工具包，基本上每个学java的人都会先在机器上装一个JDK，那他都包含哪几部分呢？让我们看一下JDK的安装目录。在目录下面有六个文件夹、一个src类库源码压缩包、和其他几个声明文件。其中，真正在运行java时起作用的是以下四个文件夹：bin、include、lib、 jre。现在我们可以看出这样一个关系，JDK包含JRE，而JRE包含JVM。bin:最主要的是编译器(javac.exe)include:java和JVM交互用的头文件lib：类库jre:java运行环境（注意：这里的bin、lib文件夹和jre里的bin、lib是不同的）总的来说JDK是用于java程序的开发,而jre则是只能运行class而没有编译的功能。
eclipse
、idea等其他IDE有自己的编译器而不是用JDK bin目录中自带的，所以在安装时你会发现他们只要求你选中jre路径就ok了。
2.final的作用
1、final类：final类不能被继承，因此final类的成员方法没有机会被覆盖，默认都是final的。在设计类时候，如果这个类不需要有子类，类的实现细节不允许改变，并且确信这个类不会再被扩展，那么就设计为final类。 final方法不能被子类的方法覆盖，但可以被继承。
2、final方法：如果一个类不允许其子类覆盖某个方法，则可以把这个方法声明为final方法。使用final方法的原因有二：第一、把方法锁定，防止任何继承类修改它的意义和实现。第二、高效。编译器在遇到调用final方法时候会转入内嵌机制，大大提高执行效率。
3、final变量（常量）用final修饰的成员变量表示常量，只能被赋值一次，赋值后值无法改变！ final修饰的变量有三种：静态变量、实例变量和局部变量，分别表示三种类型的常量。从下面的例子中可以看出，一旦给final变量初值后，值就不能再改变了。另外，final变量定义的时候，可以先声明，而不给初值，这种变量也称为final空白，无论什么情况，编译器都确保空白final在使用之前必须被初始化。但是，final空白在final关键字final的使用上提供了更大的灵活性，为此，一个类中的final数据成员就可以实现依对象而有所不同，却有保持其恒定不变的特征。
4、final参数当函数参数为final类型时，你可以读取使用该参数，但是无法改变该参数的值。注：父类的private成员方法是不能被子类方法覆盖的，因此private类型的方法默认是final类型的。 final不能用于修饰构造方法。
3.多态
1.什么是多态
面向对象的三大特性：封装、继承、多态。从一定角度来看，封装和继承几乎都是为多态而准备的。这是我们最后一个概念，也是最重要的知识点。
2.多态的定义：指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。（发送消息就是函数调用）
实现多态的技术称为：动态绑定（dynamic
binding），是指在执行期间判断所引用对象的实际类型，根据其实际的类型调用其相应的方法。
3.多态的作用：消除类型之间的耦合关系。
现实中，关于多态的例子不胜枚举。比方说按下 F1 键这个动作，如果当前在 Flash 界面下弹出的就是 AS 3 的帮助文档；如果当前在 Word 下弹出的就是 Word 帮助；在 Windows 下弹出的就是 Windows 帮助和支持。同一个事件发生在不同的对象上会产生不同的结果。
4.多态存在的三个必要条件一、要有继承；二、要有重写；三、父类引用指向子类对象。
5. 多态的好处：
1.可替换性（substitutability）。多态对已存在代码具有可替换性。例如，多态对圆Circle类工作，对其他任何圆形几何体，如圆环，也同样工作。
2.
可扩充性（extensibility）。多态对代码具有可扩充性。增加新的子类不影响已存在类的多态性、继承性，以及其他特性的运行和操作。实际上新加子类更容易获得多态功能。例如，在实现了圆锥、半圆锥以及半球体的多态基础上，很容易增添球体类的多态性。
3.
接口性（interface-ability）。多态是超类通过方法签名，向子类提供了一个共同接口，由子类来完善或者覆盖它而实现的。如图8.3 所示。图中超类Shape规定了两个实现多态的接口方法，computeArea()以及computeVolume()。子类，如Circle和Sphere为了实现多态，完善或者覆盖这两个接口方法。
4.
灵活性（flexibility）。它在应用中体现了灵活多样的操作，提高了使用效率。
5.
简化性（simplicity）。多态简化对应用软件的代码编写和修改过程，尤其在处理大量对象的运算和操作时，这个特点尤为突出和重要。
6.Java
中多态的实现方式：接口实现，继承父类进行方法重写，同一个类中进行方法重载。
4.default的含义1.default是缺省默认的意思，default在switch语句中不管放在哪都是从第一个case开始执行,当所有的case都不满足条件时，才执行default
2.default
在最后一行时下面的break可以省略不写，但如果没有在最后一行default下面需要加上break，否则执行完default后会继续执行下面的代码直到遇到break跳出循环如：
class Demo {
public static void main(String[] args) {
int x = 5;
switch (x) {
case 1:
System.out.println("A");
break;
case 2:
System.out.println("B");
break;
default:
System.out.println("
结束");
case 3:
System.out.println("C");
break;
case 4:
System.out.println("D");
break;
}
}
输出结果为：结束C
5.java中重载与重写的区别
一、首先我们来讲讲：重载(Overloading)
1
、方法重载是让类以统一的方式处理不同类型数据的一种手段。多个同名函数同时存在，具有不同的参数个数/类型。重载Overloading是一个类中多态性的一种表现。
2、Java的方法重载，就是在类中可以创建多个方法，它们具有相同的名字，但具有不同的参数和不同的定义。
调用方法时通过传递给它们的不同参数个数和参数类型来决定具体使用哪个方法, 这就是多态性。
3
、重载的时候，方法名要一样，但是参数类型和个数不一样，返回值类型可以相同也可以不相同。无法以返回型别作为重载函数的区分标准。
下面是重载的例子：
package c04.answer;//
这是包名
//
这是这个程序的第一种编程方法，在main方法中先创建一个Dog类实例，然后在Dog类的构造方法中利用this关键字调用不同的bark方法。
不同的重载方法bark是根据其参数类型的不同而区分的。
//注意：除构造器以外，编译器禁止在其他任何地方中调用构造器。
package c04.answer;
public class Dog {
Dog()
{
this.bark();
}
void bark()//bark()
方法是重载方法
{
System.out.println(\"no barking!\");
this.bark(\"female\", 3.4);
}
void bark(String m,double l)//
注意：重载的方法的返回值都是一样的，
{
System.out.println(\"a barking dog!\");
this.bark(5, \"China\");
}
void bark(int a,String n)//
不能以返回值区分重载方法，而只能以“参数类型”和“类名”来区分
{
System.out.println(\"a howling dog\");
}
public static void main(String[] args)
{
Dog dog = new Dog();
//dog.bark(); [Page]
//dog.bark(\"male\", \"yellow\");
//dog.bark(5, \"China\");
然后我们再来谈谈 重写（Overriding）
1
、父类与子类之间的多态性，对父类的函数进行重新定义。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Overriding)。在Java中，子类可继承父类中的方法，而不需要重新编写相同的方法。
但有时子类并不想原封不动地继承父类的方法，而是想作一定的修改，这就需要采用方法的重写。
方法重写又称方法覆盖。
2
、若子类中的方法与父类中的某一方法具有相同的方法名、返回类型和参数表，则新方法将覆盖原有的方法。
如需父类中原有的方法，可使用super关键字，该关键字引用了当前类的父类。
3
、.子类函数的访问修饰权限不能少于父类的；下面是重写的例子：
概念：即调用对象方法的机制。
学习总结 ：
多态性是面向对象编程的一种特性，和方法无关，简单说，就是同样的一个方法能够根据输入数据的不同，做出不同的处理，即方法的重载——有不同的参数列表（静态多态性）
而当子类继承自父类的相同方法，输入数据一样，但要做出有别于父类的响应时，你就要覆盖父类方法，
即在子类中重写该方法——相同参数，不同实现（动态多态性）
重写的主要优点 是能够定义某个子类特有的特征：
public class Father{
public void speak(){
System.out.println(Father);
}
}
public class Son extends Father{
public void speak(){
System.out.println("son");
}
}
这也叫做多态性，重写方法只能存在于具有继承关系中，重写方法只能重写父类非私有的方法。
当上例中Father类speak()方法被private时，Son类不能重写出Father类speak()方法，此时Son类speak()方法相当与在Son类中定义的一个speak()方法。
Father类speak()方法一但被final时，无论该方法被public,protected及默认所修饰时，Son类根本不能重写Father类speak()方法，
试图编译代码时，编译器会报错。例：
public class Father{
final public void speak(){
System.out.println("Father");
}
}
public class Son extends Father{
public void speak(){
System.out.println("son");
}
} //编译器会报错；
Father类speak()方法被默认修饰时，只能在同一包中，被其子类被重写，如果不在同一包则不能重写。
Father类speak()方法被protoeted时，不仅在同一包中，被其子类被重写，还可以不同包的子类重写。
重写方法的规则 ：
1、参数列表必须完全与被重写的方法相同，否则不能称其为重写而是重载。
2、返回的类型必须一直与被重写的方法的返回类型相同，否则不能称其为重写而是重载。
3、访问修饰符的限制一定要大于被重写方法的访问修饰符（public>protected>default>private）
4、重写方法一定不能抛出新的检查异常或者比被重写方法申明更加宽泛的检查型异常。例如：
父类的一个方法申明了一个检查异常IOException，在重写这个方法是就不能抛出Exception,只能抛出IOException的子类异常，可以抛出非检查异常。
而重载的规则：
1、必须具有不同的参数列表；
2、可以有不责骂的返回类型，只要参数列表不同就可以了；
3、可以有不同的访问修饰符；
4、可以抛出不同的异常；
重写与重载的区别在于：
重写多态性起作用，对调用被重载过的方法可以大大减少代码的输入量，同一个方法名只要往里面传递不同的参数就可以拥有不同的功能或返回值。
用好重写和重载可以设计一个结构清晰而简洁的类，可以说重写和重载在编写代码过程中的作用非同一般.
6.键盘事件类KeyListener,KeyEvent
1.键盘事件类（KeyEvent）是容器内的任意组件获得焦点时，组件发生键击事件，当按下，释放或键入某一个键时，组件对象将产生该事件。使用键盘事件必须给组件添加一个KeyListener 接口的事件处理器，该接口包含以下 3 个方法。
voidkeyPressed(KeyEvent e)
：按下按键时发生。
voidkeyReleased(KeyEvent e)
：松开按键时发生。
voidkeyTyped(KeyEvent e)
：敲击键盘，发生在按键按下后，按键放开前。
2.
键盘事件类的方法有以下几种。
getKeyChar()
：返回在键盘上按下的字符。
getKeyCode()
：返回在键盘上按下的字符码。
getKeyLocation()
：返回键位置。
getKeyModifiersText()
：返回描述修饰符的文
isActionKey()
：判断键是否是操作键。
setKeyChar()
：改变键字符为指定的字符。
setModifiers(int modifiers)
：改变键修饰符为指定的键修饰符。
paramString()
：生成事件状态的字符串。
8.随机产生26个英文字母
Math.rardom（）*26+97
1.‘a’不是字符串哦,“a”这个才是字符串！呵呵
char c = (char)(Math.random() * 26 + 'a');
这里面其实进行了一次系统默认的数据类型转换和一个强制类型数据类型转换默认的数据类型转换也称为隐式的数据类型转换当然了强制。。称为显式首先 Math.random() * 26 + 'a' 这里面就进行了隐式转换
Math.random() * 26
的结果是0-26的double 那么就是一个double+char 的表达式这个时候根据规则会从小数据类型默认的转换为大数据类型然后进行计算也就是说 0-26的一个double + 97.000000 那么它的结果当然也是一个double型最后强制的将这个double型转为char型
总结：小-大隐式大-小显式
另外显式的转换会丢失数据！比如double d=4.9; int i =(int)d;
到这里你认识 i是多少？想一下！
是4！呵呵
字母对应以外的数字就会得到字母以外的字符比如32 应该就是回车了
37 38 39 40
对应的←↑→↓了
不过255以上得到的字符应该得到个垃圾值因为char只能存放0-255的数据
2.'a'是char 不是string
当和char相加减时，其实是和它的ASCII码做运算
'a'
的ASCII码是97
a~z
在ASCII码中是连续的所有'a'加上0-25就是小写的字母
3.这个很明显是数据类型转换时产生的疑问?
打个比方说'a'+1到底等于多少?
这里的'a'是char型1是你说的double型.这时候就要提到java中很有意思的东西了.
就是自动类型提升.char->byte->short->int->long->float->double
这里就可以看出来'a'被先转换成了数字与1相加,然后在(char)强制转换成了char型变成了字母b
9. android inflater 用法
在实际开发中LayoutInflater这个类还是非常有用的，它的作用类似于findViewById()。不同点是LayoutInflater是用来找res/layout/下的xml布局文件，并且实例化；而findViewById()是找xml布局文件下的具体widget控件(如Button、TextView等)。具体作用： 1、对于一个没有被载入或者想要动态载入的界面，都需要使用LayoutInflater.inflate()来载入；
2、对于一个已经载入的界面，就可以使用Activiyt.findViewById()方法来获得其中的界面元素。
LayoutInflater 是一个抽象类，在文档中如下声明：
publicabstractclass LayoutInflater extends Object
获得 LayoutInflater 实例的三种方式
1.LayoutInflater
inflater = getLayoutInflater(); //调用Activity的getLayoutInflater()
2.LayoutInflater localinflater =(LayoutInflater)context.getSystemService
(Context.LAYOUT_INFLATER_SERVICE);
3.LayoutInflater inflater = LayoutInflater.from(context);
其实，这三种方式本质是相同的，从源码中可以看出：
getLayoutInflater()：
Activity 的 getLayoutInflater() 方法是调用 PhoneWindow 的getLayoutInflater()方法，看一下该源代码：
public PhoneWindow(Context context) { super(context); mLayoutInflater = LayoutInflater.from(context); }
可以看出它其实是调用 LayoutInflater.from(context)。
LayoutInflater.from(context)：
publicstaticLayoutInflater from(Context context) { LayoutInflater LayoutInflater = (LayoutInflater) context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);if(LayoutInflater ==null) {thrownewAssertionError("LayoutInflater not found."); }returnLayoutInflater; }
可以看出它其实调用 context.getSystemService()。
结论：所以这三种方式最终本质是都是调用的Context.getSystemService()。
inflate 方法 通过 sdk 的 api 文档，可以知道该方法有以下几种过载形式，返回值均是 View 对象，如下：
public View inflate (int resource, ViewGroup root) public View inflate (XmlPullParser parser, ViewGroup root) public View inflate (XmlPullParser parser, ViewGroup root, boolean attachToRoot) public View inflate (int resource, ViewGroup root, booleanattachToRoot)
示意代码：
LayoutInflater inflater = (LayoutInflater)getSystemService(LAYOUT_INFLATER_SERVICE); View view = inflater.inflate(R.layout.custom, (ViewGroup)findViewById(R.id.test)); //EditText editText = (EditText)findViewById(R.id.content);// error EditText editText = (EditText)view.findViewById(R.id.content);
对于上面代码，指定了第二个参数 ViewGroup root，当然你也可以设置为 null 值。
注意：
·inflate方法与 findViewById 方法不同；
·inflater 是用来找 res/layout下的 xml 布局文件，并且实例化；
·findViewById() 是找具体 xml 布局文件中的具体 widget 控件(如:Button、TextView 等)。
10.android:gravity与android:layout_gravity。
他们的区别在于：
android:gravity 属性是对该view中内容的限定．比如一个button 上面的text. 你可以设置该text 相对于view的靠左，靠右等位置．
android:layout_gravity
是用来设置该view相对与父view 的位置．比如一个button 在linearlayout里，你想把该button放在linearlayout里靠左、靠右等位置就可以通过该属性设置．
即android:gravity用于设置View中内容相对于View组件的对齐方式，而android:layout_gravity用于设置View组件相对于Container的对齐方式。
12.进度条变化函数
// 科普小知识，整形除以整形是整形，100以内肯定是0.几，所以用整形除以（float）型，结果为0.几几强制转换为int型*100加百分号就是百分比了
textv.setText("播放进度"+ (int)(first / (float)max * 100) +"%"+"缓存进度"
+(int) (second) / (float) max * 100 +"%");
第一种事50% 第二种是80.0%
15.构造方法作用
构造方法就是与类同名的那个方法，它的作用是可以用来初始化
class Person //
人类{
public Person(String n,int a) //
构造方法
{
name = n; age = a;
}
private string name;
private int age;
}
static void main(String[] args){
Person p = new Person("
张三",14);//这就是作用
}
new
一个对象的时候要用到构造函数,例如Hello hello = new Hello();这时调用的是Hello的无参数构造方法;
Hello hello = new Hello("hi");这个是调用Hello有参数构造方法,
在JAVA中如果不写构造方法的话,会默认加上一个无参数的构造方法,但是如果已经有了一个有参数的构造方法,那么无参数的构造方法就不会默认被加上.如果Hello类中已经有了一个有参数的构造方法,这时再使用 Hello hello = new Hello();来创建对象的时候就会出错,这就是为什么书上要强调写了有参数的构造方法就最好加一个无参数的构造方法.
1.比如说一个Class类中有很多属性,你在测试类中要用到时，如果你只有一个无参的构造函数，那么你使用这个类的并且输出类的属性值的时候，你就需要new 一个对象 然后用对象.属性 给他赋值，但是如果你有一个带参数的构造函数 那么你在调用他的时候就只需要new一下的同时就给它赋值，
Class class=new Class
（“属性值1”，“属性值2”）；这样就可以了！方便了很多，这样就是初始化！
2.
当你的所用来创建对象的类中的有些方法为private（私有方法），在其他类中，你即使创建该类的实例对象，你还是不能调用那些私有的方法和属性，这时，你可以通过构造方法去调用该类中的私有方法和设置属性，或者输出。
当你的类中，你并没有写构造方法时，系统会自动为你添加一个无参的构造方法 public 类名（）{}
就是默认在你的类中有这么一个构造方法