java学习总结1

Java总结
问题：
？？？Swing组件学习吗？
1、Java运行机制：
Java编译过程 ：*.java--Javac编译-------*.class
Java程序运行过程 ：Java *----Jvm装载类文件----Jvm运行类文件
Jvm（java virtear machine）为java程序提供了使用计算机硬件级操作系统所必要的资源

2、打印图形：
知识点 ：System.out.println(“”);/System.out.print(“”);
        If,while,for,switch
例1：

    public class Manager{
    public static void main(String [] args){
         String str = "A";
         int len = 11;//底边有11个字符组成
          
         while(len>0){
          for(int i=0;i<len;i++){
          System.out.print(str);
         }
          //转行
          System.out.println();
          len-=2;
   }
}
}

编译，运行如上程序：
AAAAAAAAAAA
AAAAAAAAA
AAAAAAA
AAAAA
AAA
A

例2：

public class Manager{
    public static void main(String [] args){
         String str = "A";
         int len = 11;//底边有11个字符组成
          
         while(len>0){
        	 for(int j = 0;j<(11-len)/2;j++){
        		 System.out.print(" ");
        	 }
          for(int i=0;i<len;i++){
          System.out.print(str);
         }
          //转行
          System.out.println();
          len-=2;
   }
}
}

编译，运行结果：
AAAAAAAAAAA
  AAAAAAAAA
    AAAAAAA
      AAAAA
        AAA
          A
例3：

public class Manager{
    public static void main(String [] args){
         String str = "A";
         int len = 1;//底边有11个字符组成
          
         while(len<=11){
        	 for(int j = 0;j<(11-len)/2;j++){
        		 System.out.print(" ");
        	 }
             for(int i=0;i<len;i++){
                 System.out.print(str);
         }
          //转行
          System.out.println();
          len+=2;
   }
}
}

编译，运行结果：
           A
         AAA
      AAAAA
    AAAAAAA
  AAAAAAAAA
AAAAAAAAAAA


3、类与对象：
知识点 ：类 ，定义具体对象所共用的属性和方法，类是一种自定义的数据类型，是一种模板。
        对象 ，具体化的类。创建方法举例：Student stu1 = new Student();
       方法的结构详解 ：
               访问限定符   返回值    方法名字(参数类型 参数名，……){
                  方法体……;
}
       方法分类 ：a、有返回值的方法和没有返回值的方法
                   有返回值的方法必须通过变量接收返回值
                 b、有参数的方法和无参数的方法
                   有参数的方法在调用的时候必须传入相同类型的参数
       对象作为方法参数传递 、
      方法的重载 ：在一个类中可以定义多个同名，但从那航速类型或者数量不同的方法。
      构造器方法： 构造器严格的说不算是“方法”----只是因为他可以传入参数。构造器方法没有返回值的定义，且必须与类名字相同。构造器也可以重载，但如果重写了一个有参数的构造器，则默认的构造器不能调用，除非在类中现实声明。
       this关键字 ：a、在类中用来指代当前的对象，用来区分属性和参数。
                     如：String name = “NetJava”;
                         Student stu1 = new Student(name);
             
                         public  Student(String name){
              this.name=name;//this用来区分属性和参数
}
                     b、在构造器中调用自己的另外一个构造器---这也是构造器与一般方法的区别：构造器可以调用构造器也可以调用方法；但在议案方法中不能调用构造器。
        值传递和引用传递 ：值传递适用于所有原始类型和String；引用传递适用于类类型或者叫做引用类型。值传递是将值copy一份传过去，引用传递copy的是地址。

4、类的继承 ：
类 ：
子类继承到了父类的所有的公有的方法和属性。如果在继承父类的过程中，父类没有提供一个默认的构造函数，子类中要重写一个带参数的构造函数。
方法的重写（OverWrite）： 子类中继承的父类的方法可以重写。如果子类中重写了父类中的方法，调用的就是子类中的实现，否则就调用父类的方法。
自动转型 ：Student uns = new UNStudent();//父类变量名用来引用子类对象
        在调用方法时：uns.study();如果子类重写了study 的方法，调用的依然是以子类中的方法。但是父类类型变量名只能调用在父类中定义了的方法，不能调用子类自己的方法。子类一次只能继承一个父类，既单根继承。
多态的实现：多态指虽然是同一类型的变量，但在具体调用时，由于重写和继承的机制，方法执行的结果不同。或者说只有在具体运行时才能知道结果是什么。
   如：//class UNStudent，ComStudent都继承父类Student，并且在这两个类中都OverWrite   study方法。如果在定义一个class Teacher 其中有方法teacStu：
Public void teacStu(Student stu){
Stu.study();
}
传入不同的参数，运行结果不同。、


接口的使用 ：接口的定义 ，在特定的用途上，我们要求子类必须重写父类中的方法，这就需要定义接口。使用关键字 interface 定义接口，接口中的属性石常量值，即不可改变的，如
public final static String com =”蓝杰”;
           接口的实现 ，与类的继承相同的是，接口也能乘坐实现类的父类，实现类对象自动转型为接口类型，多态机制同父类继承是同样的原理。当一个接口自动转型为摸个类型时，就只能调用其接口中定义的方法。
           接口的继承 ，如果某个类要实现一个继承（extends）了多个接口的的接口，就必须实现该接口中定义的方法和它的父类接口中定义的所有的方法。


抽象类的使用 ：抽象类的定义 ，关键字 abstract class 。包括没有实现的方法（继承的饿子类必须实现），如
           public abstract void draw();
和已经实现的方法。子类只能同时继承（extends）一个抽象类。
              抽象类的使用 ，抽象类也不能直接创建对象。抽象类的使用常用作“适配器”，好处是避免实现一些接口时重写空方法的麻烦。

5、Swing中事件处理机制： a、找到事件源b、确定事件类型c、设置监听器捕获事件d、将捕获的时间发送给事件处理对象，由事件处理对象进行处理e、时间对象根据具体的事件来调用事件处理方法。

例4：QQ登陆界面的实现。实现的功能是：如果都输入“admin”则显示“登陆成功！”否则，显示“账号或者密码错误，请重新输入！”

package QQLogin;

public class QQLogin extends javax.swing.JFrame{
	public static void main(String [] args){
		QQLogin login = new QQLogin();
		login.showUI();
		}
	   
	 
	public void showUI(){
		this.setTitle("QQ2010");
		this.setSize(255, 255);
		this.setVisible(true);
		this.setDefaultCloseOperation(3);
		
		java.awt.FlowLayout fl = new java.awt.FlowLayout();
		this.setLayout(fl);
		
		javax.swing.JLabel la_name = new javax.swing.JLabel("账号");
		this.add(la_name);
		javax.swing.JTextField jta_name = new  javax.swing.JTextField(18);
		this.add(jta_name);
	
		javax.swing.JLabel la_password = new javax.swing.JLabel("密码");
		this.add(la_password);
		javax.swing.JTextField jta_password = new  javax.swing.JTextField(18);
		this.add(jta_password);
	
	    javax.swing.JButton bu_login = new javax.swing.JButton("登陆");
	    this.add(bu_login);
	    //添加动作事件监听器 
	    LoActionListner al = new LoActionListner(jta_name,jta_password);
	    bu_login.addActionListener(al);//事件机制中的方法调用时自动调用的
	
	}

}

 

package QQLogin;

import java.awt.event.ActionEvent;

//定义一个动作时间处理类，用来实现动作事件接口
public class LoActionListner implements java.awt.event.ActionListener{
	private javax.swing.JTextField jta_name;
	private javax.swing.JTextField jta_password ;
	//重写构造函数，传入参数
	public LoActionListner(javax.swing.JTextField jta_name,javax.swing.JTextField jta_password ){
		this.jta_name = jta_name;
		this.jta_password = jta_password;
		}
	
	public void actionPerformed(ActionEvent e){
		//得到框中的数据
		String strname =jta_name.getText();
		String strpassword = jta_password.getText();
		
		if(strname.equals("admin")&&strpassword.equals("admin")){
			System.out.println("登陆成功！");
			}else{
				System.out.println("账号或密码错误，请重新输入！");
			}
		
		
		
	}

}

[/img]
   




6.《简单画板》程序实现
例5：《简单画板》的实现

package SampleDraw;


import java.awt.event.MouseEvent;
import java.awt.Graphics;



public class SampleDraw {
	//程序入口
	public static void main(String [] args){
		SampleDraw sd = new SampleDraw();
		sd.showUI();
		}
	
	
	public void showUI(){
		javax.swing.JFrame jf=new javax.swing.JFrame();
		jf.setSize(600,500);
		jf.setTitle("贾懂画板");
		jf.setResizable(false);
		jf.setVisible(true);
		jf.setDefaultCloseOperation(3);
		//给窗体添加鼠标事件监听器，完成一个内部类
		jf.addMouseListener(new java.awt.event.MouseAdapter(){
			 public void mouseReleased(MouseEvent e) {
				 OnReleased(e);}
			});
		
		
		//获取画布对象
		g=jf.getGraphics();
		//事件调用的方法
		
		
		
		
	}
	private void OnReleased( MouseEvent e){
		
		if(count==0){
			x1=e.getX();
			y1=e.getY();
			count++;
		}else{
			x2=e.getX();
			y2=e.getY();
			count--;
			g.drawLine(x1, y1, x2, y2);
			}
	}
	private Graphics g;
	private int count=0;
	private int x1,y1,x2,y2;

}

编译，运行结果：

 

本例子总结 ：1、一个方法中不可以定义另一个方法
            2、通过事件触发才可以调用的方法（onReleased）只能在事件触发时调用，并且它的调用方法不同于一般的方法（OnReleased(e)）。

例6：画板颜色选择和图形选择的实现：

package SampleDraw;


import java.awt.event.ActionEvent;

import java.awt.event.MouseEvent;
import java.awt.Graphics;



public class SampleDraw {
	//程序入口
	public static void main(String [] args){
		SampleDraw sd = new SampleDraw();
		sd.showUI();
		}
	
	//桌面显示方法
	public void showUI(){
		javax.swing.JFrame jf=new javax.swing.JFrame();
		jf.setSize(600,500);
		jf.setTitle("贾懂画板");
		jf.setResizable(false);//设置界面的大小不可改变
		jf.setVisible(true);
		jf.setDefaultCloseOperation(3);
		//设置页面布局方式
		java.awt.FlowLayout fl = new java.awt.FlowLayout();
		jf.setLayout(fl);
		//获取画布对象
		g=jf.getGraphics();
		
		//给窗体添加鼠标事件监听器，完成一个内部类
		jf.addMouseListener(new java.awt.event.MouseAdapter(){
			 public void mouseReleased(MouseEvent e) {
				 OnReleased(e);}
			});
		
		
		
		
		
		javax.swing.JButton bu_color = new javax.swing.JButton("选颜色");
		jf.add(bu_color);
		//设置颜色选择按钮的事件监听器
		bu_color.addActionListener(new java.awt.event.ActionListener(){
			public void actionPerformed(ActionEvent e){
				showColorSelecter();//调用弹出颜色选择器的方法
				
			}
		}  );
		
		//创建两个单选按钮
		javax.swing.JRadioButton jr_line = new javax.swing.JRadioButton("line");
		jr_line.setActionCommand("line");
		javax.swing.JRadioButton jr_rect=  new javax.swing.JRadioButton("rect");
		jr_rect.setActionCommand("rect");
		jf.add(jr_line);
		jf.add(jr_rect);
		this.shapeGroup.add(jr_line);
		this.shapeGroup.add(jr_rect);
		
		
		
		
		
	}
	
	
	
	
	
	
   //设置颜色选择器的方法
	private void showColorSelecter(){
		//这是JColorChooser中的一个public staic 方法，可直接调用
		this.c = javax.swing.JColorChooser.showDialog(null, "请选择颜色", java.awt.Color.BLACK);
		}
	/***********************************各种形状类的定义*****************************************/
	//创建一个内部类，实现接口NetJavaShape
	public class ImpLine implements NetJavaShape {
	      public void draw(java.awt.Graphics g,int x1,int y1,int x2,int y2,java.awt.Color c){
			g.setColor(c);//设置画板的颜色
			g.drawLine(x1, y1, x2, y2);
		}
	}
	//矩形类 
	public class ImpRect implements NetJavaShape{
		public void draw(java.awt.Graphics g,int x1,int y1,int x2,int y2,java.awt.Color c){
			g.setColor(c);//设置画板的颜色
			int x=x1;
			int y=y1;
			AbsoV jj=new AbsoV();
			
			int width=jj.AV(x1,x2);
			int height=jj.AV(y1, y2);
			g.drawRect(x, y, width, height);
			
		}
	}
	
	//圆形类
	//public class ImpFillOval implements NetJavaShape{
		//public void draw(java.awt.Graphics g,int x1,int y1,int x2,int y2,java.awt.Color c){
			//g.setColor(c);//设置画板的颜色
			//g.drawOval(x, y, width, height);
		//}
	//}
	//重写Graphic类中fillOval方法
	//public  void drawOval(int x, int y, int width, int height){
		
		
	//};
	
	
	private void OnReleased( MouseEvent e){
		
		if(count==0){
			x1=e.getX();
			y1=e.getY();
			count++;
		}else{
			x2=e.getX();
			y2=e.getY();
			count--;
			//看用户选中的是什么图形，根据用户的选择，创建不同的对象
			String command = shapeGroup.getSelection().getActionCommand();
			//默认为划线
			NetJavaShape shape = new ImpLine();//自动转型
			if(command.equals("line")){
				shape = new ImpLine();
			}else{
				shape = new ImpRect();
				
			}
			shape.draw(g, x1, y1, x2, y2, this.c);
			
			
			
			
			}
		
	}
	private java.awt.Color c = java.awt.Color.BLACK;//颜色属性
	private Graphics g;
	private int count=0;
	private int x1,y1,x2,y2;
	private javax.swing.ButtonGroup shapeGroup = new javax.swing.ButtonGroup();//形状选择组对象，用来加入形状选择按钮

} 

编译运行后的结果：

 
问题 ：1、一些特殊图形的绘制方法如何完善。
      2、注意形状选择组对象中的到command的实现
      3、如何实现：“新增绘制图形是，不需要修改SampleDraw中代码。只要将新实现的形状类放到指定的目录下，当程序启动时，有多少个形状类，界面上自然就会出现多少个可供选择的选框”？



7、高级Swing组之菜单的应用
菜单的基本概念：
有两种基本菜单，一种是基于菜单条的，一般家在JFrame组件上；一种是JpopupMenu。

菜单条上的菜单有三部分组成:javax.swing.JMenuBar类，菜单条对象；javax.swing.JMenu 菜单目录对象；javax.swing.JMenuItem,菜单条条目类。
例7：菜单添加实例：

//窗体上有菜单的菜单的窗体类
public class MenuText extends javax.swing.JFrame{
	public static void main(String [] args){
		MenuText mt = new MenuText();
		mt.showUI();
		}
	
	public void showUI(){
		this.setTitle("菜单添加例子");
		this.setSize(200,100);
		this.setDefaultCloseOperation(3);
		this.setLayout(new java.awt.FlowLayout());
		this.setJMenuBar(createMB());//设置窗体的菜单条
		this.setResizable(false);
		
		this.setVisible(true);
	}
	
      private javax.swing.JMenuBar createMB(){
    	  //创建菜单条
    	  javax.swing.JMenuBar mb = new javax.swing.JMenuBar();
    	  //1.创建菜单目录对象“文件”
    	  javax.swing.JMenu m_file = new javax.swing.JMenu("文件");
    	 //1.1创建文件菜单下的菜单项
    	  javax.swing.JMenuItem m_open = new javax.swing.JMenuItem("打开");
    	  javax.swing.JMenuItem m_new  = new javax.swing.JMenuItem("新建");
    	  javax.swing.JMenuItem m_exit = new javax.swing.JMenuItem("退出");
    	  //1.2将菜单项加到文件菜单目录下
    	  m_file.add(m_open);
    	  m_file.add(m_new);
    	  m_file.add(m_exit);
    	  //2.创建数据管理菜单
    	  javax.swing.JMenu m_oper = new javax.swing.JMenu("数据管理");
    	//2.1创建文件菜单下的菜单项
    	  javax.swing.JMenuItem m_add = new javax.swing.JMenuItem("新增");
    	  javax.swing.JMenuItem m_modi  = new javax.swing.JMenuItem("新建修改");
    	  javax.swing.JMenuItem m_delete = new javax.swing.JMenuItem("删除");
    	  javax.swing.JRadioButton m_rrr = new javax.swing.JRadioButton("总在最前");
    	  javax.swing.JMenuItem m_about = new javax.swing.JMenuItem("关于");
    	  //2.2将菜单项加到文件菜单目录下
    	  m_oper.add(m_add);
    	  m_oper.add(m_modi);
    	  m_oper.add(m_delete);
    	  m_oper.add(m_about);
    	  m_oper.addSeparator();//加一个分割条
    	  m_oper.add(m_rrr);
    	  
    	  //将文件和数据管理菜单加到菜单条上
    	  mb.add(m_file);
    	  mb.add(m_oper);
    	  
    	  return mb;
      }

}

编译运行后：

例8：

import java.awt.event.ActionEvent;
//1、菜单事件处理历程
//2、内置窗体实现
//窗体上有菜单的菜单的窗体类
public class MenuText extends javax.swing.JFrame{
	//创建一个JDesktopPane类的对象，就可以在窗体中添加内置窗体
	private javax.swing.JDesktopPane jdp= new javax.swing.JDesktopPane();
	
	public static void main(String [] args){
		MenuText mt = new MenuText();
		mt.showUI();
		}
	
	//处理菜单事件的方法（统一实现）
	public void proessMenuEvent(ActionEvent e){
		String command = e.getActionCommand();//得到事件源上的命令关键字
		if(command.equals("open")){
			//弹出内部对话框
			javax.swing.JInternalFrame jif = new javax.swing.JInternalFrame();
			jif.setTitle("我是内部窗体");
			jif.setSize(200,100);
			jif.setMaximizable(true);//能在窗体空间内最大化
			jif.setVisible(true);
			
			jdp.add(jif);
			
			
		}else if(command.equals("new")){
			javax.swing.JOptionPane.showInputDialog("要创建什么？");
			
		}else if(command.equals("exit")){
			System.exit(0);
			
		}
		
		
		
	}
	
	public void showUI(){
		this.setTitle("菜单添加例子");
		this.setSize(600,500);
		this.setDefaultCloseOperation(3);
		this.setLayout(new java.awt.FlowLayout());
		this.setJMenuBar(createMB());//设置窗体的菜单条
		this.setResizable(false);
		this.setContentPane(jdp);//将JDesktopPane对象添加到窗体中
		
		this.setVisible(true);
	}
	
      private javax.swing.JMenuBar createMB(){
    	  //创建菜单条
    	  javax.swing.JMenuBar mb = new javax.swing.JMenuBar();
    	  //1.创建菜单目录对象“文件”
    	  javax.swing.JMenu m_file = new javax.swing.JMenu("文件");
    	 //1.1创建文件菜单下的菜单项
    	  javax.swing.JMenuItem mi_open = new javax.swing.JMenuItem("打开");
    	  mi_open.setActionCommand("open");//设置菜单的命令关键字
    	  javax.swing.JMenuItem mi_new  = new javax.swing.JMenuItem("新建");
    	  mi_new.setActionCommand("new");
    	  javax.swing.JMenuItem mi_exit = new javax.swing.JMenuItem("退出");
    	  mi_exit.setActionCommand("exit");
    	  //创建内部类的菜单事件监听器对象
    	  java.awt.event.ActionListener al = new java.awt.event.ActionListener(){
    		  public void actionPerformed(ActionEvent e){
    			  //调用统一的方法处理
    			  proessMenuEvent( e);
    		  };
    	
    	   };
    	   
    	 //1.2给菜单项加上事件监听器
           mi_open.addActionListener(al);
           mi_new.addActionListener(al);
           mi_exit.addActionListener(al);
    	  //1.3将菜单项加到文件菜单目录下
    	  m_file.add(mi_open);
    	  m_file.add(mi_new);
    	  m_file.add(mi_exit);
    	  //2.创建数据管理菜单
    	  javax.swing.JMenu m_oper = new javax.swing.JMenu("数据管理");
    	//2.1创建文件菜单下的菜单项
    	  javax.swing.JMenuItem mi_add = new javax.swing.JMenuItem("新增");
    	  javax.swing.JMenuItem mi_modi  = new javax.swing.JMenuItem("新建修改");
    	  javax.swing.JMenuItem mi_delete = new javax.swing.JMenuItem("删除");
    	  javax.swing.JRadioButton mi_rrr = new javax.swing.JRadioButton("总在最前");
    	  javax.swing.JMenuItem mi_about = new javax.swing.JMenuItem("关于");
    	  //2.2将菜单项加到文件菜单目录下
    	  m_oper.add(mi_add);
    	  m_oper.add(mi_modi);
    	  m_oper.add(mi_delete);
    	  m_oper.add(mi_about);
    	  m_oper.addSeparator();//加一个分割条
    	  m_oper.add(mi_rrr);
    	  
    	  //将文件和数据管理菜单加到菜单条上
    	  mb.add(m_file);
    	  mb.add(m_oper);
    	  
    	  return mb;
      }

}

编译运行结果：

 
本例总结 ：
1、 在javax.swing.JOptionPane类中，提供 了非常多的弹出各种你所能想象到的对话框的静态调用方法。



例9：第二种Menu：JPopupMenu
弹出式菜单示例，就是把javax.swing.JMenuBar对象换成javax.swing.JPopupMenu对象，然后调用要弹出菜单功能的swing组件的setComponentPopupMenu方法传入JPopupMenu对象即可。

import java.awt.event.ActionEvent;


public class PopMenuTest extends javax.swing.JFrame{
	public static void main(String [] args){
		PopMenuTest pm = new PopMenuTest();
		pm.showUI();
	}
	
	
	public void showUI(){
		this.setTitle("添加JTree组件和弹出菜单示例");
		this.setSize(600,500);
		this.setDefaultCloseOperation(3);
		this.setResizable(false);
		this.setLayout(new java.awt.FlowLayout());
		//创建一个默认的JTree组件对象
		javax.swing.JTree tree = new javax.swing.JTree();
		javax.swing.JPopupMenu pop = creatPopupMenu();
		//将弹出菜单对象设到树上
		tree.setComponentPopupMenu(pop);  
		//将默认树加到界面上
		this.add(tree);
		
		
		
		this.setVisible(true);
	}
	
	//创建弹出对象
	private javax.swing.JPopupMenu creatPopupMenu(){
		javax.swing.JPopupMenu pop = new javax.swing.JPopupMenu();
		//1.1创建弹出菜单下的菜单项
		javax.swing.JMenuItem mi_add = new javax.swing.JMenuItem("添加");
		mi_add.setActionCommand("open");//设置菜单命令关键字
		javax.swing.JMenuItem mi_delete = new javax.swing.JMenuItem("删除");
		mi_delete.setActionCommand("delete");//设置菜单命令关键字
		javax.swing.JMenuItem mi_mod = new javax.swing.JMenuItem("修改");
		mi_mod.setActionCommand("mod");//设置菜单命令关键字
		
		
		//创建内部类的菜单事件监听器对象
		java.awt.event.ActionListener  al = new java.awt.event.ActionListener(){
			public void actionPerformed(ActionEvent e){
				//统一调用的处理方法
				javax.swing.JOptionPane.showMessageDialog(null, "你想执行的操作是"+e.getActionCommand());
			   }
			};
			
			
		//给菜单项添加监听器
			mi_add.addActionListener(al);
			mi_delete.addActionListener(al);
			mi_mod.addActionListener(al);
			
		
		pop.add(mi_add);
		pop.add(mi_delete);
		pop.add(mi_mod);
		
		
		return pop;
	}

}

编译运行后的结果是：

注 ：command设计模式的理解：通过设置组件的关键字，使同一菜单中所有的事件都调用同一方法。








8、常用关键字总结
简单总结下各种关键字的用法，因为书上都写得比较清楚了，照抄也只是再记一遍而已，所以我有重点的找出一部分知识点来：
1、 可见性修饰关键字
public       可以放在属性、方法、类等前。Public限定的类在一个文件中只允许有一个，且类名必须与文件名相同。如果放在属性前，就说明可以直接通过 对象.属性 格式来访问对象的属性。
Private        在方法前加上，则方法就只能有内部类的方法或者构造器调用。（？？？？）

一般情况下，我们在定义 类、方法、属性、构造器 的可见性时，不采用private 就采用 public ，即要不彻底公开，要不严密封闭。
Protected 介于以上两个限制附之间，用来界定方法，子类可以继承，只有在同包范围内可以访问。
2、 static关键字
static方法 ：使用此关键字限定的方法称为 静态方法 或者 类方法 。直接通过 类名.静态方法名();  调用即可。
Static属性 ：又称之为 类属性。可以不创建类的对象而直接调用。（？？？？？在不同的文件中也可以不创建类的对象直接调用吗）另一个特征就是，类的某一个对象的static属性值被改变后，这个类的所有对象的static的属性值都会被改变。
        Static 属性可以直接在任何方法中调用，但static方法中，则只能直接调用static属性，非static属性需先创建对象。

3、 super关键字 （？？？？？？）
4、 package关键字
在不同的包中引用类，需要引入（import）或者全限定名字。
5、 final关键字
放在属性前面，属性就是常量，即这个属性的值不可改变。如果放在方法前面，当子类继承时，就不可以重写此方法。





9、数组与基本数据类型
数组定义的两种方法：
String[] st =new String[3];
st[0] = “net”;
st[1] = “java”;
st[2] = “vb”;

等同于：
String[] st = new String[3]{“net”,”java”,”vb”};

数组的排序：
例10：冒泡、选择、插入、希尔四种排序方法

//数组排序测试
public class SortArray {
	public static void main(String [] args){
		int[] sra = creatArray(0);
		System.out.println("****冒泡排序中原始数组如下****");
		printArray(sra);
		System.out.println("****冒泡排序结果*****");
		int[] item =maopao(sra);
		printArray(item);
		
		sra = creatArray(6);
		System.out.println("***选择排序中原始数组如下****");
		printArray(sra);
		System.out.println("****选择排序结果*****");
		item =xuanze(sra);
		printArray(item);
		
		sra = creatArray(7);
		System.out.println("***插入排序中原始数组如下****");
		printArray(sra);
		System.out.println("****插入排序结果*****");
		item =charu(sra);
		printArray(item);
		
		sra = creatArray(8);
		System.out.println("***希尔排序中原始数组如下****");
		printArray(sra);
		System.out.println("****希尔排序结果*****");
		item =shell(sra);
		printArray(item);
	}

	
	
	//打印数组的方法
	public static void printArray(int[] ia){
		if(ia==null){
			return;
		}
		for(int i = 0;i<ia.length;i++){
			System.out.print(ia[i]+"     ");
		}
		System.out.println("");
	}
	
	
	//获得随即数组的方法
	public static int[] creatArray(int len){
		int[] ia = new int[len];
		for(int i=0;i<len  ;i++){
		//通过创建随即对象调用生成随即数的方法
		java.util.Random ran = new java.util.Random();
		ia[i]=ran.nextInt(100);
		}
		return ia;
	}
	
	
	//定义冒泡排序的方法
	public static int[] maopao(int[] ia){
		for(int i=0;i<ia.length;i++){
		    for(int j=i+1;j<ia.length;j++){
		    	if(ia[j]<ia[i]){
		    		int temp = ia[i];
		    		ia[i] = ia[j];
		    		ia[j] = temp;
		    	}
		    }
		 }
		return ia;
	}
		
     
		
	//定义选择排序法
	public static int[] xuanze(int[] ia){
		for(int i=0;i<ia.length;i++){
			int lowerIndex = i;
			for(int j=i+1;j<ia.length;j++){
				if(ia[j]<ia[lowerIndex]){
					int temp = ia[lowerIndex];
					ia[lowerIndex] = ia[j];
					ia[j] = temp;
				}
			}
			}
		return ia;
		}
	//定义插入排序的方法
	public static int[] charu(int[] ia){
		for(int i=1;i<ia.length;i++){
			for(int j=i;j>0;j--){
				if(ia[j]<ia[j-1]){
					int temp = ia[j];
					ia[j] = ia[j-1];
					ia[j-1] = temp;
					}
			}
			}
		return ia;
	}
//定义希尔排序的方法
	public static int[] shell(int[] ia){
		for(int increment=ia.length/2;increment>0;increment/=2){
			//给数组按increment长度切段
			for(int i=increment;i<ia.length;i++){
				//遍历increment后所有元素
				int temp = ia[i];
			   int j;
				for(j=i;j>=increment;j-=increment){
					//给以increment为间距的元素对应排序
					if(temp<ia[j-increment]){
						ia[j]=ia[j-increment];
					}else{
						break;
					}
				}
				ia[j]=temp;
			}
			}
		return ia;
	}
	}

编译运行结果：

 
多维数组 ：java编程语言没有像其他语言那样提供多维数组，不过二维数组就是以一维数组为元素的数组。
使用数组管理学生信息：
通过创建扫描器对象，调用其中的方法来接收输入的值。

public class Student {
	public Student(int age,String name){
		this.age=age;
		this.name=name;
	}
	public Student(){}
	
	public void showInfo(){
		System.out.println("姓名"+name+"年龄"+age);
	}
	private int age;
	private String name;
	
}

public class Manager {
	public static void main(String [] args){
		//创建一个扫描器对象，用来接收用户在命令行的输入
		java.util.Scanner sc=new java.util.Scanner(System.in);
		System.out.println("请输入学生个数（数字）");
		int studentCount = sc.nextInt();
		Student[] stArray=creatArray(studentCount);
		
		print(stArray);
	}
	
	//通过输入，创建学生数组的方法
	public static Student[] creatArray(int count){
		Student[] x=new Student[count];
		java.util.Scanner sc=new java.util.Scanner(System.in);
	    for(int i=0;i<count;i++){
        System.out.println("请输入第"+(i+1)+"学生姓名");
		String name=sc.next();
		System.out.println("请输入第"+(i+1)+"学生年龄");
		int age=sc.nextInt();
        x[i]=new Student(age,name);
		}
		return x;
	}
	
	
	//输出所有学生信息的方法
	public static void print(Student[] x){
		System.out.println("输出所有的学生信息如下");
		for(int i=0;i<x.length;i++){
		     x[i].showInfo();
			}
		}

}

编译运行结果：

自定义队列实现 ：
创建自定义队列类，他可以像数组一样有序的存放数据，不过他与数组的最大区别是他可以有一些特殊的方法，且没有固定长度。

package SampleList;
/******************Student类***************************/
public class Student {
	private int age;
	private String name;
	
	public Student(String name,int age){
		this.age = age;
		this.name = name;
	}
	
	public void showInfo(){
		System.out.println("姓名是"+name+"年龄是"+age);
	}

}

 

/******************自定义队列的接口*******************************/
public interface NetJavaList<E> {
	//增加一个学生对象的方法
	void add(E st);
	//取得指定位置的元素
    E get(int index);
    //得到队列的长度
    int getSize();

}

 

/*******************************s实现学生队列的类**************/
public class StList<E> implements NetJavaList<E>{
	//默认构造函数
	public StList(){}
	//指定初始队列的大小
	public StList(int initcount){
		this.initcount=initcount;
	}
	//指定初始大小和每次增长比率
	//public StList(int initcount,int increcount){
	//	this.initcount=initcount;
	//	this.increcount=increcount;
		
	//}
	
	
	
	
	//给数组增长的方法
	//public  Object[] expand(){
	//	for(int i=0;i<stA.length;i++){
	//		if(stA[i]==null){break;}else{
	//				Object[] dest=new Object[stA.length+increcount];
	//			   stA=dest;
	//			}
	//		
	//			}
	//	return stA;
	//	}
		
	
	
	
	//增加一个学生对象的方法
	public void add(E st){
		//判断属性数组是否已满，如满给数组增长
	//	stA=expand();
		Object[] x = new Object[stA.length+1];
		x[stA.length] = st;
		//使用系统提供的数组cop的方法吧stA中的元素全部复制到x数组中
		System.arraycopy(stA, 0, x, 0, stA.length);
		stA=x;
	}
	//增加制定个数对象的方法
	//public void addX(int increcount){}
	
	
	//向队列中制定位置插入一个元素
	public void insert(E e,int index){
		Object[] dest = new Object[stA.length+1];
		System.arraycopy(stA, 0, dest, 0, index);
		System.arraycopy(stA, index, dest, index+1, stA.length-index);
		dest[index]=e;
	     stA=dest;	
	     }
	//取得指定位置的元
	public E get(int index){
    	E e=(E)stA[index];
    	return e;
    }
	//删除队列中制定位置的元素
	public void delete(int index){
		Object[] dest = new Object[stA.length-1];
		System.arraycopy(stA, 0, dest, 0, index);
		System.arraycopy(stA, index+1, dest, index, stA.length-index-1);
		stA=dest;
	}
	
	//将另一个队列的所有对象加到队列后面
	public void addAll(StList<E> list){
		Object[] dest1=list.stA;
		Object[] dest = new Object[stA.length+list.getSize()];
		System.arraycopy(stA, 0, dest, 0,stA.length);
		System.arraycopy(dest1, 0, dest, stA.length, list.getSize());
		stA=dest;
	}
    //得到队列的长度
    public int getSize(){
    	return stA.length;
    }
    
    private int initcount=0;
    //队列内部初始数组
    private Object[] stA = new Object[initcount];
    //private int increcount=1;
}

 

/****************************管理类**********************************/
public class Manager {
	public static void main(String [] args){
		StList<Student> nj1=new StList<Student>();
	    for(int i=0;i<5;i++){
	    	Student st = new Student("Name"+i,i+10);
	    	nj1.add(st);
	    }
	    Student st=new Student("贾懂凯",20);
	    nj1.insert(st,2);
	    nj1.delete(3);
	    StList<Student> nj2=new StList<Student>();
	    for(int i=0;i<5;i++){
	    	Student st1= new Student("nnnnnname"+i,i+10);
	    	nj2.add(st1);
	    }
	    nj1.addAll(nj2);
	    print(nj1);
	    
	    
	    
	    StList<Student> nj3=new StList<Student>(10);
	    nj3=nj1;
	    print(nj3);
	}
	
	//打印队列的方法
	public static void print(NetJavaList<Student> nj){
		for(int i=0;i<nj.getSize();i++){
			nj.get(i).showInfo();
		}
	}

}

编译运行结果：

10、高级Swing之五子棋游戏的实现(未完，待续)

附：送上一张自己做的很有用的图片

上标A表示为abstract

空三角标识方法在implements或者extends的接口/类中已经有定义

实心三角表示该类继承同时实现，继承和实现的类/接口中都有该方法