Java 初学者要知道的一些知识（未完待续）

最新推荐文章于 2022-06-24 09:11:00 发布

BusyMonkey

最新推荐文章于 2022-06-24 09:11:00 发布

阅读量1.1k

点赞数 1

分类专栏： Android 文章标签： Android应用

本文链接：https://blog.csdn.net/dopamy_busymonkey/article/details/42557889

版权

Android 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

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 米
无参数构造函数 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 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.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
查看 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);
   }
} 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 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 bytes4261 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);
      }
   }
}

以上代码运行输出结果为：