java知识------我的积累（一）

关于IO知识：
键盘录入语句
BufferedReader  bufr = 
new BufferedReader(new InputStreamReader(System.in));


以字符串方式接受键盘录入数据：
String str = new String();


str = readLine(bufr);

FileOutputStream和FileInputStream创建磁盘文件的输入输出流对象

创建FileInputStream实例对象时，指定的文件应当是存在和可读的，
创建FileOutputStream实例对象时，如果指定的文件已经存在，这个文件中的原来内容将被清除

创建FileOutputStream实例对象时，可以指定还不存在的文件名，不能指定一个已被其他程序打开的文件

java中的代码块
静态代码块>mian方法>构造代码块>构造方法。


/构造块：直接在类中定义且没有加static关键字的代码块称为{}构造代码块。构造代码块在
创建对象时被调用，每次创建对象都会被调用，并且构造代码块的执行次序优先于类构造函数。

静态代码块:在java中使用static关键字声明的代码块。静态块用于初始化类，为类的属性初始化。
每个静态代码块只会执行一次。由于JVM在加载类时会执行静态代码块，所以静态代码块先于主方法执行。

3：构造函数。
发现子类构造函数运行时，先运行了父类的构造函数。为什么呢?
原因：子类的所有构造函数中的第一行，其实都有一条隐身的语句super();
super(): 表示父类的构造函数，并会调用与参数相对应的父类中的构造函数。而super():是在调用父类中空参数的构造函数。
为什么子类对象初始化时，都需要调用父类中的函数？(为什么要在子类构造函数的第一行加入这个super()?)
因为子类继承父类，会继承到父类中的数据，所以必须要看父类是如何对自己的数据进行初始化的。
所以子类在进行对象初始化时，先调用父类的构造函数，这就是子类的实例化过程。


"注意：子类中所有的构造函数都会默认访问父类中的空参数的构造函数，
因为每一个子类构造内第一行都有默认的语句super(); 
如果父类中没有空参数的构造函数，那么子类的构造函数内，必须通过super语句指定要访问的父类中的构造函数。
如果子类构造函数中用this来指定调用子类自己的构造函数，那么被调用的构造函数也一样会访问父类中的构造函数。

在方法覆盖时，注意两点：
1：子类覆盖父类时，必须要保证，子类方法的权限必须大于等于父类方法权限可以实现继承。否则，编译失败。
2：覆盖时，要么都静态，要么都不静态。 (静态只能覆盖静态，或者被静态覆盖)


想要定义匿名内部类：需要前提，内部类必须继承一个类或者实现接口。
匿名内部类的格式：new 父类名&接口名(){ 定义子类成员或者覆盖父类方法 }.方法。

class Outer
		{
			int x=3;
	
			public void function()
			{
				new absDemo()
				{
					void show()
					{
						System.out.println("x = "+x);
					}
				}.show();
			}
		}

字符串的方法：


1：构造方法：将字节数组或者字符数组转成字符串。
String s1 = new String();//创建了一个空内容的字符串。 
String s2 = null;//s2没有任何对象指向，是一个null常量值。
String s3 = "";//s3指向一个具体的字符串对象，只不过这个字符串中没有内容。
//一般在定义字符串时，不用new。
String s4 = new String("abc");
String s5 = "abc"; 一般用此写法
new String(char[]);//将字符数组转成字符串。
new String(char[],offset,count);//将字符数组中的一部分转成字符串。


2：一般方法：
按照面向对象的思想：
2.1 获取：
2.1.1：获取字符串的长度。length();
2.1.2：指定位置的字符。char charAt(int index);
2.1.3：获取指定字符的位置。如果不存在返回-1，所以可以通过返回值-1来判断某一个字符不存在的情况。
int indexOf(int ch);//返回第一次找到的字符角标
int indexOf(int ch,int fromIndex); //返回从指定位置开始第一次找到的角标
int indexOf(String str); //返回第一次找到的字符串角标
int indexOf(String str,int fromIndex);


int lastIndexOf(int ch);
int lastIndexOf(int ch,int fromIndex);
int lastIndexOf(String str);
int lastIndexOf(String str,int fromIndex);
2.1.4：获取子串。
String substring(int start);//从start位开始，到length()-1为止.
String substring(int start,int end);//从start开始到end为止。//包含start位，不包含end位。
substring(0,str.length());//获取整串
2.2 判断：
2.2.1：字符串中包含指定的字符串吗？
boolean contains(String substring);
2.2.2：字符串是否以指定字符串开头啊？
boolean startsWith(string);
2.2.3：字符串是否以指定字符串结尾啊？
boolean endsWith(string);
2.2.4：判断字符串是否相同
boolean equals(string);//覆盖了Object中的方法，判断字符串内容是否相同。
2.2.5：判断字符串内容是否相同，忽略大小写。
boolean equalsIgnoreCase(string) ;


2.3 转换：
2.3.1：通过构造函数可以将字符数组或者字节数组转成字符串。
2.3.2：可以通过字符串中的静态方法，将字符数组转成字符串。
static String copyValueOf(char[] );
static String copyValueOf(char[],int offset,int count);
static String valueOf(char[]);
static String valueOf(char[],int offset,int count);
2.3.3：将基本数据类型或者对象转成字符串。
static String valueOf(char);
static String valueOf(boolean);
static String valueOf(double);
static String valueOf(float);
static String valueOf(int);
static String valueOf(long);
static String valueOf(Object);
2.3.4：将字符串转成大小写。
String toLowerCase();
String toUpperCase();
2.3.5：将字符串转成数组。
char[] toCharArray();//转成字符数组。
byte[] getBytes();//可以加入编码表。转成字节数组。
2.3.6：将字符串转成字符串数组。切割方法。
String[] split(分割的规则-字符串);
2.3.7：将字符串进行内容替换。注意：修改后变成新字符串，并不是将原字符串直接修改。
String replace(oldChar,newChar);
String replace(oldstring,newstring);
2.3.8： String concat(string); //对字符串进行追加。
String trim();//去除字符串两端的空格
int compareTo();//如果参数字符串等于此字符串，则返回值 0；如果此字符串按字典顺序小于字符串参数，则返回一个小于 0 的值；如果此字符串按字典顺序大于字符串参数，则返回一个大于 0 的值。


以下是 Java判断字符串是否为空的几种方法


方法一: 最多人使用的一个方法, 直观, 方便, 但效率很低.     "".equals("") 约156毫秒


方法二: 比较字符串长度, 效率高, 是我知道的最好一个方法.  "".length()<=0约15毫秒


方法三: Java SE 6.0才开始提供的办法,效率和方法二基本上相等,但出于兼容性考虑,推荐使用方法二或方法四. "".isEmpty() 约15毫秒


方法四:这是种最直观,简便的方法,而且效率也非常的高,与方法二、三的效率差不多 if(""=="")约16毫秒
小程序：

package L78Z;
import java.io.*;
import java.util.Scanner;
public class ioTest001 {
/*小程序：实现键盘录入一个字符串，经过翻转后输出*/
	public static void main(String[] args) throws IOException {
		/*BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
		String str = null;
		str = bufr.readLine();
		reverseStr(str);
	}

	private static void reverseStr(String str) {
		for(int i = str.length()-1;i>=0;i--){
			System.out.print(str.charAt(i));
		}*/
		/*使用scanner类获取键盘录入*/
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入姓名： ");
		String name = sc.nextLine();
		System.out.println("请输入年龄：");
		int age = sc.nextInt();
		System.out.println("请输入工资： ");
		float salary = sc.nextFloat();
		System.out.println("您的基本信息如下： ");
		System.out.println("姓名："+name+"\n"+"年龄 ："+age+"\n"+"工资： "+salary+"\n");
	}

}

方法一：从控制台接收一个字符，然后将其打印出来

import java.io.*;
public static void main(String [] args) throws IOException{ 
         System.out.print("Enter a Char:"); 
         char i = (char) System.in.read(); 
         System.out.println("your char is :"+i); 
} 

单例设计模式：
饿汉式

public void Single
{
	private Single(){}//私有化构造函数
	private static Single s = new Single();//创建私有并静态的本类对象
	public static void getInstance()//定义公有并静态方法，返回该对象。
	{
		return s;
	}
}

懒汉式

public void Single
{
	private Single(){}//私有化构造函数
	private static Single s = null;//创建私有并静态的本类对象
	public static void getInstance()//定义公有并静态方法，返回该对象。
	{
		if(s == null)
			s = new Single();
		return s;
	}
}

现在终于理清这三者之间的关系了，总结如下：

package basicTest;

/*
* 这个例子很好的演示了静态代码块   构造代码块  构造函数在程序运行时的加载次序
* 
* 静态代码块在初始化对象是就执行而且只执行一次，
*         如果静态代码块与主函数在一个大括号内，则先加载静态代码块
* 
* 此外，我们也可以看到，构造代码块的执行优先于构造方法
* */

class Code{
   //静态代码块
        static{
        System.out.println("Code的静态代码块");
        }
   //构造方法
        public Code(){
        System.out.println("Code的构造方法");
        }
   //构造代码块
        {
            System.out.println("Code的构造块");
    }
    }
public class CodeBlock03{
     {
      System.out.println("CodeBlock03的构造块");    
     }
     static{
        System.out.println("CodeBlock03的静态代码块");
        }
        public CodeBlock03(){
             System.out.println("CodeBlock03的构造方法");
            }
      public static void main(String[] args){
            System.out.println("CodeBlock03的主方法");
            new Code();
            /*new Code();
            new CodeBlock03();
            new CodeBlock03();*/
          }
    }

下面关于java的多线程做个小小的总结！

1.JAVA多线程实现方式
JAVA多线程实现方式主要有三种：继承Thread类、实现Runnable接口、使用ExecutorService、Callable、Future实现有返回结果的多线程。只有最后一种是带返回值的。

2.继承Thread类实现多线程
继承Thread类的方法尽管被我列为一种多线程实现方式，但Thread本质上也是实现了Runnable接口的一个实例，它代表一个线程的实例，并且，启动线程的唯一方法就是通过Thread类的start()实例方法。start()方法是一个native方法，它将启动一个新线程，并执行run()方法。这种方式实现多线程很简单，通过自己的类直接extend Thread，并复写run()方法，就可以启动新线程并执行自己定义的run()方法。例如：
public class MyThread extends Thread {
　　 public void run() {
　　 System.out.println("MyThread.run()");
　　 }
}
在合适的地方启动线程如下：
MyThread myThread1 = new MyThread();
MyThread myThread2 = new MyThread();
myThread1.start();
myThread2.start();

3.实现Runnable接口方式实现多线程
如果自己的类已经extends另一个类，就无法直接extends Thread，此时，必须实现一个Runnable接口，如下：

public class MyThread extends OtherClass implements Runnable {
　　 public void run() {
　　 System.out.println("MyThread.run()");
　　 }
}

为了启动MyThread，需要首先实例化一个Thread，并传入自己的MyThread实例：
MyThread myThread = new MyThread();
Thread thread = new Thread(myThread);
thread.start();

myThread.start();

事实上，当传入一个Runnable target参数给Thread后，Thread的run()方法就会调用target.run()，参考JDK源代码：

public void run() {
　　 if (target != null) {
　　 target.run();
　　 }
}