Java总结大全

           Java总结大全

 1在进行变量定义时候 不要超过其范围。第一字符用单引号字符串用双引号

2如果为数组分配了内存空间及指定了数组的大小 那么其长度就不可改变了

3因为使用字符串常量 直接使用一个String对象的效率 要高于使用new关键字初始化方式所以在程序中建议使用直接初始化方式

 4除非是内部类 否则一般的类不能使用private protected 关键字

5使用this关键字只可以 完成对构造方法的调用 其他的一般的方法不能这样使用

6在类的设计中 一般把类的成员变量 定义为private 方法定义为public 设定set get

6子类覆盖父类的方法时 覆盖方法的返回值 类型是可以是原来返回类型的子类型

7在子类调用父类的构造方法中  使用super 对父类构造方法的调用一定是子类构造方法的第一句

8当把一个对象类型转换成一种类型时  对象类型和新类型  需要在同一个类的结构中 且9类与类之间存在继承关系才可以进行正确转换

10所谓动态绑定 是指只有在程序运行时 才能正确的判断对象的类型

 11动态绑定方法不包括 private static final 因为使用这些关键字 修饰的方法 编译器可以很准确的知道调用那个方法 不需要进行动态绑定

12Packet 必须要放在第一句

13在实际应用中 最好显示的指明类 方法 属性 因为对于一个默认的类来说 其他人可以在14包内加入新的类 不利于程序的安全性  最好使用 public private protected

15使用this来引用成员变量 也仅限于 在构造方法和set方法的隐藏成员变量的时候调用

16Java中静态变量可以通过创建对象来访问 但是一般情况下 使用类明来访问

17静态方法中 不能初始化对象

18判断对象相等 obj。equals 两个对象的hashcode值一定相等 相反不一定

19不能通过 new thread().start() 方法产生一个线程如果这样做是没有意义的  20thread.run（）方法只有方法的声明 没有方法的主题

21出现死锁后 如果想继续运行别的代码 可以使 ctrl +c

 

1. 两种从键盘读取字符的输入方式

A．InputStreamReader reader=new InputStreamReader(System.in);

BufferedReader br=new BufferedReader(reader);

try {

    String s=br.readLine();

} catch (IOException e) {

    // TODO Auto-generated catch block

    e.printStackTrace();

}

 

B．Scanner input=new Scanner(System.in);

String s=input.nextint();

2. 多线程的方法实现 （两种）（实现Runnable接口 继承thread）

 Public class jiekou implements Runnable{

    Public void run(){}

}

　　Public class jicheng extends thread{

　　Public void run(){}

　　}

3. 实现线程的同步方法（synchronized  lock  wait() notify()）

package xianchengtongbu;

//使用wait 和 notify 方法

public class Xianchengtongbu2 {

  public static void main(String []args){

      Staff s=new Staff();

      Thread produceThread=new Thread(new producer(s));

      Thread getThread=new Thread(new Consumer(s));

      produceThread.start();

      getThread.start();

  }

}

//staff店员的意思

class Staff{

    private int i=0;

  //从工厂拿到产品

    public synchronized void addProducer(){

        if(i<20&i>0){

            i++;

            System.out.println("生产者生产地"+i+"产品");

            notifyAll();

        }else{

        try {

            wait();

        } catch (InterruptedException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        }

        }

    }

    //消费者从店里拿到产品

    public synchronized void getProducer(){

        if(i>0){

            i--;

            System.out.println("生产者生产地"+i+"产品");

            notifyAll();

        }else{

        try {

            wait();

        } catch (InterruptedException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        }

        }

    }

   

}

//生产者

class  producer implements Runnable{

    Staff s;

    public producer(Staff s){

        this.s=s;

    }

    public void run(){

        System.out.println("生产者开始生产产品");

        while(true){

            s.addProducer();

        }

       

    }

   

}

//消费者

class Consumer implements Runnable{

    Staff s;

    public Consumer(Staff s){

        this.s=s;

    }

    public void run(){

       

        System.out.println("开始消费产品");

        while(true){

            s.getProducer();

        }

    }

}

 

 

package xianchengtongbu;

 

import java.util.concurrent.locks.Lock;

import java.util.concurrent.locks.ReentrantLock;

 

public class Thread_tongbu {

    int i=100;

    //线程同步方法

 public synchronized void sell1(){

     boolean flag=true;

      if(i>0){

          i--;

          System.out.println(Thread.currentThread().getName());

      }else{

          flag=false;

      }

      try {

        Thread.sleep(15);

    } catch (InterruptedException e) {

        // TODO Auto-generated catch block

        e.printStackTrace();

    }

 }

 //线程同步代码块

 public void sell2(){

     boolean flag=true;

     synchronized(this){

         if(i>0){

              i--;

              System.out.println(Thread.currentThread().getName());

          }else{

              flag=false;

          }

          try {

            Thread.sleep(15);

        } catch (InterruptedException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        }

     }

 }

 //lock 同步方法

 

  public void sell3(){

      Lock lock =new ReentrantLock();

      boolean flag=true;

      lock.lock();

      if(i>0){

          i--;

          System.out.println(Thread.currentThread().getName());

      }else{

          flag=false;

      }

      lock.unlock();

      try {

            Thread.sleep(15);

        } catch (InterruptedException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        }

  }

 

  

}

4.网络编程实例：

import java.io.BufferedReader;

import java.io.BufferedWriter;

import java.io.IOException;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.io.OutputStreamWriter;

import java.net.ServerSocket;

import java.net.Socket;

import java.net.UnknownHostException;

 

public class Music_copy {

   

  public void send(){

    try {

        Socket s=new Socket("localhost",3434);

        BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));

        bw.write("你好");

        bw.close();

    } catch (UnknownHostException e) {

        // TODO Auto-generated catch block

        e.printStackTrace();

    } catch (IOException e) {

        // TODO Auto-generated catch block

        e.printStackTrace();

    } 

   

  }

  public void service(){

      try {

        ServerSocket s=new ServerSocket(3434);

        Socket s1=s.accept();

        BufferedReader br=new  BufferedReader(new InputStreamReader(s1.getInputStream()));

        String a="";

        a=br.readLine();

        System.out.println(a);

        s1.close();

    } catch (IOException e) {

        // TODO Auto-generated catch block

        e.printStackTrace();

    }

     

  }

}

 

 

4. 实现排序的几种排序的方法（基于集合 数组）