Java 初学者要知道的一些知识（未完待续）
http://www.runoob.com/java/java-examples.html
Android 项目的目录结构
1、src
项目源文件
2、gen有 R.java 资源文件，随.xml 文件自动生成
3、Android X.X 有 Android.jar 是Java 归档文件，里面有所需要的库
4、assets 放置mp3. mp4 等音频，视频文件，大文件
5、res 资源文件夹
drawable- 图标文件 png jpg
layout 界面布局文件
value 软件上所需要显示的各种文字，可以存放多个 xml 文件，也可以存不同类型数据
array.xml color.xml dimens.xml
6、AndroidManifest.xml 总配置文件，记录应用中所使用的各种组件，提供的功能
7、project.properties 记录项目中所需要的环境信息，android 版本等
Activity 四种状态：
1、Runing：Activity启动入栈，在屏幕最前端，栈最顶端，此时它处于可见并可和用户交互的激活状态。
2、Paused：Activity 被另一个透明或者Dialog样式的 Activity 覆盖时的状态。此时它依旧与窗口管理器保持连接，系统继续维护其内部状态，任然可见，但它已经失去了焦点数，故不可以与用户交互。
3、Stop：Activity 被另一个 Activity 覆盖，失去焦点并不可见时处于stoped状态。
4、Killed：Activity 被系统杀死回收或者没有被启动时处于 killed 状态。
Java 中的 extends 与 implements
extends 是继承父类，只要那个类不是声明为 final 或者那个类定义为 abstract 的就能继承，Java 中不支持多重继承，但是可以用接口来实现，这样就要用到 implements，继承只能继承一个类，但是 implements 可以实现多个接口，用逗号分开就行
class A extends B implements C，D，E
Java 中的抽象类与接口
一、抽象类
定义：public abstract class Fruit｛
。。。
｝// 不能实例化对象，Fruit fruit = new Fruit（）；
继承：public class Apple extends Fruit｛
。。。
｝
抽象方法：public abstract class Shape {
。。。
public abstract void draw（）；
。。。
｝
二、接口
定义：public interface InterfaceA ｛
void methodA（）；
} // 接口中的方法都是抽象方法
实现：public class ClassA implements InterfaceA ｛
public void methodA（）｛
System.out.println ("....");
}
} // 类 ClassA 实现接口InterfaceA
抽象类实现：public abstract class ClassB implements InterfaceA ｛
｝// 抽象类 ClassB 实现接口 InterfaceA ，但没实现具体实现方法methodA（）；
子类实现接口：public class ClassBSub implements InterfaceA ｛
public void methodA（）｛
System.out.println(".....");
}
}
接口和抽象类共同点与不同点
共同点：都可以有抽象方法。
不同点： 1、抽象类中可以有非抽象方法，接口中只有抽象方法。
2、抽象类中可以有各种类型变量，接口中只有 Static、final。
3、抽象类中可以有静态代码和静态方法，而接口中不能。
4、一个类只能继承一个抽象类，一个类可以实现多个接口。
Java 中接口与抽象类解决的多继承问题：
对于一个类实现多个接口的情况，因为接口只有抽象方法，具体方法只能由实现接口的类实现，在调用的时候始终只会调用实现的类方法（不存在歧义），因此不存在多重继承的第二个缺点；而又因为接口只有静态的常量，但是由于静态变量是在编译期间决定调用关系的，即使存在一定的冲突也会在编译时提示出错，而引用静态变量一般直接使用类名或接口名，从而避免产生歧义，因此也不存在多重继承的第一个缺点。对于一个接口继承多个父接口的情况也一样不存在这些缺点。
Android 回调函数
回调函数就是那些自己写的，但是不是自己来调用的，而是给别人来调用的函数。
消息响应数就可以看成是回调函数，因为是让系统在合适的时候去调用，这不过是消息相应函数就是为了处理消息的，所以就拿出来单做一类了。其本质上就是回调函数。
但是回调函数不是只有消息响应函数一种，比如在内核变成中，驱动程序就要提供一些回调函数，当一个设备的数据读写完成后，让系统调用这些回调函数来执行一些后续工作。
回调函数赋予程序员这样一种行为，让自己编写的代码能够跳出正常的程序控制流，适应具体的运行环境在正确的运行时间执行。
Java 中关于字符串拼接的问题，单引号是用来套双引号的。
Java 实例-方法重载
先来看下方法重载（Overloading）的定义：如果有两个方法的方法名相同，但参数不一致，哪么可以说一个方法是另一个方法的重载。 具体说明如下：
- 方法名相同
- 方法的参数类型，个数顺序至少有一项不同
- 方法的返回类型可以不相同
- 方法的修饰符可以不相同
- main方法也可以被重载
以下实例演示了如何重载 MyClass 类的 info 方法：
class MyClass {
int height;
MyClass() {
System.out.println("无参数构造函数");
height = 4;
}
MyClass(int i) {
System.out.println("房子高度为 "
+ i + " 米");
height = i;
}
void info() {
System.out.println("房子高度为 " + height
+ " 米");
}
void info(String s) {
System.out.println(s + ": 房子高度为 "
+ height + " 米");
}
}
public class MainClass {
public static void main(String[] args) {
MyClass t = new MyClass(3);
t.info();
t.info("重载方法");
//重载构造函数
new MyClass();
}
}
输出结果：
房子高度为 3 米 房子高度为 3 米 重载方法: 房子高度为 3 米 无参数构造函数
Java-方法覆盖
方法重载与方法覆盖区别如下：
- 方法重载(Overloading)：如果有两个方法的方法名相同，但参数不一致，哪么可以说一个方法是另一个方法的重载。
- 方法覆盖（Overriding）：如果在子类中定义一个方法，其名称、返回类型及参数签名正好与父类中某个方法的名称、返回类型及参数签名相匹配，那么可以说，子类的方法覆盖了父类的方法。
以下实例演示了 Java 方法覆盖（Overriding）代码的实现：
public class Findareas{
public static void main (String []agrs){
Figure f= new Figure(10 , 10);
Rectangle r= new Rectangle(9 , 5);
Figure figref;
figref=f;
System.out.println("Area is :"+figref.area());
figref=r;
System.out.println("Area is :"+figref.area());
}
}
class Figure{
double dim1;
double dim2;
Figure(double a , double b) {
dim1=a;
dim2=b;
}
Double area() {
System.out.println("Inside area for figure.");
return(dim1*dim2);
}
}
class Rectangle extends Figure {
Rectangle(double a, double b) {
super(a ,b);
}
Double area() {
System.out.println("Inside area for rectangle.");
return(dim1*dim2);
}
}
以上代码运行输出结果为：
Inside area for figure. Area is :100.0 Inside area for rectangle. Area is :45.0
Java 文件写入
import java.io.*;
public class Main {
public static void main(String[] args) {
try {
BufferedWriter out = new
BufferedWriter(new FileWriter("outfilename"));
out.write("w3cschool");
out.close();
System.out.println
("文件创建成功！");
}
catch (IOException e) {
}
}
}
创建成功后当前目录下就会生成一个名为 outfilename 的文件并将"w3cschool菜鸟教程"字符串写入该文件。
Java 读文件
import java.io.*;
public class Main {
public static void main(String[] args) {
try {
BufferedReader in = new BufferedReader
(new FileReader("test.log"));
String str;
while ((str = in.readLine()) != null) {
System.out.println(str);
}
System.out.println(str);
} catch (IOException e) {
}
}
}
Java 文件删除
import java.io.*;
public class Main
{
public static void main(String[] args)
{
try{
File file = new File("c:\\test.txt");
if(file.delete()){
System.out.println(file.getName() + " 文件已被删除！");
}else{
System.out.println("文件删除失败！");
}
}catch(Exception e){
e.printStackTrace();
}
}
}
Java 中的 Finally 关键一般与try一起使用，在程序进入try块之后，无论程序是因为异常而中止或其它方式返回终止的，finally块的内容一定会被执行 。
Java 实例 - 获取指定主机的IP地址
以下实例演示了如何使用 InetAddress 类的 InetAddress.getByName() 方法来获取指定主机（网址）的IP地址：import java.net.InetAddress;
import java.net.UnknownHostException;
public class GetIP {
public static void main(String[] args) {
InetAddress address = null;
try {
address = InetAddress.getByName
("www.w3cschool.cc");
}
catch (UnknownHostException e) {
System.exit(2);
}
System.out.println(address.getHostName() + "="
+ address.getHostAddress());
System.exit(0);
}
}
以上代码运行输出结果为：
www.w3cschool.cc=222.73.134.120
Java 实例 - 查看端口是否已使用
import java.net.*;
import java.io.*;
public class Main {
public static void main(String[] args) {
Socket Skt;
String host = "localhost";
if (args.length > 0) {
host = args[0];
}
for (int i = 0; i < 1024; i++) {
try {
System.out.println("查看 "+ i);
Skt = new Socket(host, i);
System.out.println("端口 " + i + " 已被使用");
}
catch (UnknownHostException e) {
System.out.println("Exception occured"+ e);
break;
}
catch (IOException e) {
}
}
}
}
以上代码运行输出结果为：
…… 查看 17 查看 18 查看 19 查看 20 查看 21 端口 21 已被使用 查看 22 查看 23 查看 24
Java 实例 - 获取本机ip地址及主机名
import java.net.InetAddress; public class Main { public static void main(String[] args) throws Exception { InetAddress addr = InetAddress.getLocalHost(); System.out.println("Local HostAddress: "+addr.getHostAddress()); String hostname = addr.getHostName(); System.out.println("Local host name: "+hostname); } }
以上代码运行输出结果为：
Local HostAddress: 192.168.1.4 Local host name: harsh
Java 实例 - 获取远程文件大小
import java.net.URL;
import java.net.URLConnection;
public class Main {
public static void main(String[] argv)
throws Exception {
int size;
URL url = new URL("http://www.w3cschool.cc/wp-content/themes/w3cschool.cc/assets/img/newlogo.png");
URLConnection conn = url.openConnection();
size = conn.getContentLength();
if (size < 0)
System.out.println("无法获取文件大小。");
else
System.out.println("文件大小为：" +
+ size + " bytes");
conn.getInputStream().close();
}
}
以上代码运行输出结果为：
文件大小为：4261 bytes
Java 实例 - Socket 实现多线程服务器程序
import java.io.IOException;
import java.io.PrintStream;
import java.net.ServerSocket;
import java.net.Socket;
public class MultiThreadServer implements Runnable {
Socket csocket;
MultiThreadServer(Socket csocket) {
this.csocket = csocket;
}
public static void main(String args[])
throws Exception {
ServerSocket ssock = new ServerSocket(1234);
System.out.println("Listening");
while (true) {
Socket sock = ssock.accept();
System.out.println("Connected");
new Thread(new MultiThreadServer(sock)).start();
}
}
public void run() {
try {
PrintStream pstream = new PrintStream
(csocket.getOutputStream());
for (int i = 100; i >= 0; i--) {
pstream.println(i +
" bottles of beer on the wall");
}
pstream.close();
csocket.close();
}
catch (IOException e) {
System.out.println(e);
}
}
}
以上代码运行输出结果为：
Listening Connected