Java基础知识学习01

0 项目，包，文件，类

Mytest是自己建的java工程，包含src和JRE System Libery。其中src是存放自己的代码的地方，JRE包含程序运行时所需要的各种文件；在src下包含Test包，一个包就是许多.java文件的合集，src下可以有很多的包，在写程序时Import 包名表明用这个包；一个包下可以有很多的.java文件，在该文件下写代码，一个文件下只能有一个public类。

1 定义学生类并调用及static的事项

 package Test;//在Test包下

 public class Main{
 //快速生成main方法，写main然后alt+/便可快速生成
     public static void main(String[] args) {
         //直接通过类调用，静态所修饰的成员优先于对象随着类的加载而加载
         Student.graduatefrom="abcd";
         //在创建时直接初始化
         Student s=,"M");

         //也可以调用get和set方法
         Student s2=new Student();
         s2.setAge();
         s2.setGednder("W");
         s2.setName("小李");
         //显示出来
         s.show();
         s2.show();

         //这样显示的是s和s2的地址
         System.out.println(s);
         System.out.println(s2);
     }
 }

 //在一个文件下只能有一个public类
 class Student{
     //类中使用私有的成员变量做到封装思想
     private String name;
     private int age;
     private String gednder;
 //当这两个人都毕业于同一院校时，每次构建对象便要重新赋值比较麻烦，可以考虑赋值一次便能让这个类的所有对象都共享。
     static String graduatefrom;

     //无参构造，只要人为定义一个构造方法后java便不会再自动生成默认构造方法
     public Student(){}

     //有参构造可以用来初始化成员变量，右键--source可以自动生成构造方法，get set方法
     public Student(String name, int age, String gednder) {
         super();
 //方法内部的变量名和类中成员变量名字相同，用this，this其实是Student对象的地址
         this.name = name;
         this.age = age;
         this.gednder = gednder;
     }

 //生成get和set方法因为成员变量使用private修饰无法在其他类中访问，，同过get set方法便可以读写这就是封装的思想
     public String getName() {
         return name;
     }

     public void setName(String name) {
         this.name = name;
     }

     public int getAge() {
         return age;
     }

     public void setAge(int age) {
         this.age = age;
     }

     public String getGednder() {
         return gednder;
     }

     public void setGednder(String gednder) {
         this.gednder = gednder;
     }

     public void show(){
         //输出syso快捷键alt+/
         System.out.println(name+" "+age+" "+" "+gednder+" "+graduatefrom);
     }

 }

 /*关于静态方法的几点注意
  * 1：静态方法只能调用静态方法
  * 2：非静态方法可以都调用
  * 3：静态方法随着类加载而加载优先于对象加载因此没有this指针
  *
  */

2 模拟发牌

了解ArrayList，Collections的使用

 package Test;

 import java.util.ArrayList;
 import java.util.Collections;

 /*
  *模拟发牌
  * 建牌
  * 洗牌
  * 发牌
  */
 public class Main {
     public static void main(String[] args) {

         //牌由花色和数字组成
         String[] color = {"梅花","黑桃","方片","红桃"};
         //数字
         String[] num = {"A","2","3","4","5","6","7","8","9","10","J","Q","K"};

         //装牌
         ArrayList<String> box = new ArrayList<String>();
         for (int i = 0; i < color.length; i++) {
             for (int j = 0; j < num.length; j++) {
                 box.add(color[i] + num[j]);
             }
         }
         box.add("大王");
         box.add("小王");

         //shuffle随机置换元素顺序
         Collections.shuffle(box);

         //发牌实质就是创建三个数组然后存入，可以用汉语作为对象名
         ArrayList<String> 李大狗= new ArrayList<String>();
         ArrayList<String> 李二狗 = new ArrayList<String>();
         ArrayList<String> 李三狗 = new ArrayList<String>();

         for (int i = 0; i < box.size() - 3; i++) {
             if(i % 3 == 0) {
                 李大狗.add(box.get(i));
             }
             else if(i % 3 == 1) {
                 李二狗.add(box.get(i));
             }
             else if(i % 3 == 2) {
                 李三狗.add(box.get(i));
             }
         }

         System.out.println("李大狗:" + 李大狗);
         System.out.println("李二狗:" + 李二狗);
         System.out.println("李三狗:" + 李三狗);

         System.out.println("底牌");

         for(int x = box.size() - 3;x < box.size();x++) {
             System.out.println(box.get(x));
         }
     }

 }

3 多线程火车票

Main.class

 package Test;

 /*模拟火车票售票
  *  使用多线程模拟多个窗口售票
  *  当售票完后火车站同样欢迎，因此无需关闭
  */

 public class Main{
     public static void main(String[] args) {
         //创建Runnable实现对象
         TicketThread tt =new TicketThread();
         //创建线程对象，有多个线程,因为ticket是一定，所以创建线程时都要使用tt
         Thread t=new Thread(tt);
         t.setName("窗口1");
         Thread t2=new Thread(tt);
         t2.setName("窗口2");
         Thread t3=new Thread(tt);
         t3.setName("窗口3");
         t.start();
         t2.start();
         t3.start();
     }
 }

TicketThread.class----会出现多线程问题

 package Test;
 //实现Runnable接口启动线程
 public class TicketThread implements Runnable{
     int tickets=100;
     @Override
     public void run() {
         // TODO Auto-generated method stub
         while(true){
             if(tickets>0){
                 /*当有进程睡眠时会出现错误
                  * 当t来的时候有票进入if在里面睡眠，此时t2进来，t1还在睡眠因此仍有票，t2进入，同理t3也可进入
                  * 当t t2 t3出来后，票就开始自减就会出现问题。
                  */

                 try {
               //如果线程处于wait，sleep，join三个方法时候，则会抛出InterruptedException
                     Thread.sleep(100);
                 } catch (InterruptedException e) {
                     // TODO Auto-generated catch block
                     e.printStackTrace();
                 }

                 //Thread是类名，类名+方法名直接调用方法，该方法必须是静态（static）方法
                 System.out.println(Thread.currentThread().getName()+":"+tickets--);
             }
         }
     }

 }

解决问题代码：

 package Test;
 //实现Runnable接口启动线程
 public class TicketThread implements Runnable{
     int tickets=100;
     Object obj=new Object();
     @Override
     public void run() {
         // TODO Auto-generated method stub
         while(true){
             if(tickets>0){
                 //同步代码块   obj为要锁的对象
                 synchronized (obj) {
                     try {
                           //如果线程处于wait，sleep，join三个方法时候，则会抛出InterruptedException
                                 Thread.sleep(100);
                             } catch (InterruptedException e) {
                                 // TODO Auto-generated catch block
                                 e.printStackTrace();
                             }

                             //Thread是类名，类名+方法名直接调用方法，该方法必须是静态（static）方法
                             System.out.println(Thread.currentThread().getName()+":"+tickets--);
                 }

             }
         }
     }

 }

对上面是代码的改善

 package Test;
 //实现Runnable接口启动线程
 public class TicketThread implements Runnable{
     int tickets=100;
     Object obj=new Object();
     @Override
     public void run() {
         // TODO Auto-generated method stub
         while(true){
             method();
         }
     }

    //用synchronized修饰后该方法就会安全的方法,该方法是非静态方法因此默认同步锁对象为this
     //若为静态方法时同步锁对象为当前类的字节码对象
     private synchronized void method(){
         if(tickets>0){
             //同步代码块   obj为要锁的对象,但会造成运行效率低
                 try {
                       //如果线程处于wait，sleep，join三个方法时候，则会抛出InterruptedException
                             Thread.sleep(100);
                         } catch (InterruptedException e) {
                             // TODO Auto-generated catch block
                             e.printStackTrace();
                         }

                 //Thread是类名，类名+方法名直接调用方法，该方法必须是静态（static）方法
                 System.out.println(Thread.currentThread().getName()+":"+tickets--);
         }
     }

 }