java阶段学习总结

1、类与对象
     要知道java中的代码是以类为单位的；而类中由两个关键部分组成：方法和属性。通过方法的调用可以改变属性的值。

     a、通过类创建对象，调用对象的方法； 无论要多少对象、都可以通过这个类创建具体的对象，调用每一个对象所具有的方法（在类中已定义）就可以改变每个对象自己的属性。这就是类。关键字是class
       其定义格式是：访问修饰符   class  类名（）{}
            例：//定义一个类
               public class Class(){
                    //创建一个对象
                    Student std=new Student();
                    //调用这个方法
                    std.study();
                    //若要再创建一个对象
                    Student std1=new Student();
                    //同样可以添加其方法，设置属性；就是通过添加方法和属性使得其对象不同
               }

      b、方法的基本结构；
               方法在类中定义，通过对象的调用；方法的基本结构如下:
               访问修饰符  返回值  方法名字（参数类型  参数变量名）{
                            方法体、、、
                               }
                例：public  int study(int score){
                                           return score=+score;
                   }//此处返回值类型为int，故必须用return;若没有返回值则应该用void;
                例：public  void study(int score){
                                          score =+score;
                                        }


       c、方法中有无参数，如果括号中有参数、在调用时必须传入指定类型的参数变量；
                例：//设置有参数的方法
                    public  void score(int grade){
                                  scor=scor+grade;
                 }
                 //调用时，传入指定类型的参数
                    //先实例化一个对象
                    Student std=new Student();
                 //调用，并传入参数
                    std.score(3);


2、构造器方法
         a、创建某个类的对象的一般格式是：
                     类名  变量名=new 类名（）；
                  例：Book  bo=new Book();
                   //这里的Book（）就叫做Book类的构造器方法；
                  每一个类默认的都有一个无参构造器方法，即通过new 类名（）调用而创建对象。我们也可以自己给类重新定义构造器方法，这方法就叫做构造器方法的重载。
                  例：//创建一个树对象，使用无参构造器方法
                      Tree tree1=new Tree();
                   //创建一个树对象，使用一个参数的构造器方法
                      String name="榕树";
                   Tree tree2=new Tree(name);
                   //创建一个树对象，使用两个参数的构造器方法
                      String name="榕树"；
                      int high="5";
                   Tree tree3=new Tree(name,high);
          使用构造器重载的好处是：在对象创建时，就可以初始对象内部属性的值；
          b、方法重载：在一个类中可以定义多个同名，但参数类型和数量不同的方法这就叫做方法重载
                      例：//定义一个普通的方法
                          public void  run(int speed){
                                sp=speed;
                          }
                          //定义一个方法，利用方法重载
                          public void  run(String name){
                                 na=name;
                          }//此为参数类型不同
                          //定义一个方法，使用方法重载
                          public void run(int speed,String name){
                                 sp=speed;
                                 na=name;
                          }
                      其调用时，参数应该相对应；构造器方法没有任何返回值的定义，且必须与类名相同。
          构造器方法只有在创建对象时期调用---对于一个对象来说，它的构造器只能调用一次。
          构造器和方法一样，都可以重载；它的主要用途是可以传入不同参数列表；使在创建对象时初始化对象的某些属性值；
         this关键字
             this在例中用来指代当前对象、形象地比如为“人类中的“我                     例：//创建对象
                         int score ="80";
                     Student  stu=new Student(score);
                     //构造时传入参数，初始化score的属性值
                         public Student (int score){
                     this.score=score
                     }
                     另一用途是在构造器中调用自己的另一构造器；这就是构造一般方法的区别：构造器中可以调用构造器，也可以调用一般方法；但在一般方法中，不能调用构造器。


           c、值传递与引用传递
                   值传递：java中数据类型分为两大类：一类是引用类型，也叫做类型;其传递是通过类创建的对象的变量名字。另一类是原始类型，即八大数据类型；这些数据类型在传递时遵循“值传递”规则。
                   其中主要是引用传递：通过引用变量名，实际使用的是变量名所指向d 对象 ；同样的，在方法的参数中、参数是引用类型，传入的则只是一个对象名字的引用，而不是这个对象的本身；
               例：//在一个类中定义一个方法
                   public class Teacher{
                   public void Test(Student stu){
                        String newScore="80";
                        stu.setScore(newScore);
                   }
                 }
                 //然后在主函数中调用，并传入一个对象；
                   public static void main(String []  args){
                      //创建对象
                         Student stu=new Student();
                      //调用前，设置名字
                         stu.setScore(50);
                      //实例化一类的对象
                         Teacher tea=new Teacher();
                      //传入对象引用名
                         tea.Test(stu);
                     int Score=stu.getScore();
                   }

3、类的继承和实现和作用
          类继承的作用是减少重复代码的编写，充分利用代码的使用率；
          类继承的实现是通过关键字extends帮子类继承父类中的方法和属性；
                     例：//一个子类继承父类
                        public class Son  extends  Father{

                        }//这样，子类就有了父类中的方法和属性；在后面的代码中可以直接调用父类中的方法和属性；
           b、方法的重写：在类的继承中，为了使继承的对象与父类不同、可以重写子类的方法；重写子类的方法后，父类的方法则不再调用；
           c、自动转型：子类类型自动转为父类类型；
                     例：//父类类型变量名用来引用子类对象
                         Father  son=new Son();
                         此前提是前者必须是后者的父类；
                转型之后，在使用son变量时、如果子类重写了父类的方法，则调用的就是子类中的实现，否则调用父类中的方法；通过转型之后、通过父类类型变量的引用，只能调用在父类中定义的方法，不能调用子类中自己的方法；子类一次只能继承一个父类，这就叫做单根继承。
           d、多态的实现：
                   多态是：相同类型的对象调用相同的方法的时候，由于继承和重写机制、得到的结果不一定相同；
                     例：//先编写一个简单类
                         public class Son{
                             //实例化一个对象
                             Son  son=new Son();
                             //设置名字
                             son.setName("children");
                             //父类中的方法
                             public void play(){
                               System.out.println("谁在玩"+getName());
                             }
                            
                         }
                         //再编写一个子类，继承父类
                         public class xiaoming extends Son{
                     //重写父类中的方法
                         public void play(){
                                System.out.println("老大"+getName());
                     }           
                     }
                     //再编写一个子类，继承父类
                         public class zhanghua extends Son{
                     //重写父类中的方法
                         public void play(){
                             System.out.println("老二"+getName());
                             }           
                      }
                      //一个简单Father类，来使用Son类
                         public class Father{
                     //陪伴两孩子玩的游戏
                         public void playGream(Son a,Son b){
                                  a.play();
                                  b.play();
                             }
                         }
                      //主函数中实现
                         public static void main(String[] args){
                      //用父类变量名来引用子类对象
                          Son  son1=new  xiaoming();
                      son1.setName("小明");
                      Son  son2=new zhanghua();
                      son2.setName("张华");
                      //创建一个父亲对象
                          Father fa=new Father();
                      //带两孩子玩耍
                          fa.playGrame(son1,son2);
                      }
    
                e、接口的使用
                        接口：类作用有两个，一个生成对象调用其方法、另一个是用作给其它类来继承。而接口就是在某种特定的用途上、要求子类必须重写父类中的方法，从而需要的就是接口；其关键字是interface。它的规则是接口中定义的是一个没有任何方法体的实现方法；只要定义方法返回类型，方法名、参数表不能有实现。而且方法前是否写了public限定符，接口中的方法都是public型的。
                        接口的实现：使用关键字implements，实现类中、必须重写接口中定义的方法。
                        与类的继承相同的是：接口也可称作实现类的父类，实现类对象自动转型为接口类型；多态机制同子父类继承是同样原理。与类继承不同的是一个类可以实现多个接口；当一个类实现多个接口，自动转为某个接口类型时，就只能调用在其接口中定义的方法。

                 f、接口的继承
                       接口与接口之间也可以通过extends关键字来实现；与类不同的是接口同样可以继承多个接口；
                  例：一个Graphics继承Oval，rect等多个接口
                      public interface Graphics  extends  Oval,rect、、、{}
              g、抽象类
                    抽象类是介于接口与类之间：竟可以定义已实现的方法，也可以定义像接口中没有实现的方法：继承的子类就必须实现。抽象类的关键字是abstract.
              例：//定义一个抽象类
                 public abstract class Graphics {
              //抽象方法的定义，继承的子类必须实现
                public abstract void draw();
              //也可以定义已实现的方法
                 public void setColor(int c){
              this.color=c;
              }
              }
              像这样，抽象类中定义的方法，如没有实现、前面就必须加上abstract关键字，这样就变成了抽象方法；当子类继承时、在子类中必须实现抽象类的abstract方法。
               抽象类不能直接创建对象、当一个接口中定义有多个方法，子类都必须实现时、就要使用抽象类。
               例如编写鼠标监听器实现类时，只需要自己的类extends MouseAdapter类、重写只需要使用的某一个方法即可、这样就不需要重写所有接口中定义的方法。


4、常用关键字
       a、访问修饰符：public  private  protected它们的访问权限范围依次从大到小；
       b、static关键字：使用static限定的有关方法称为静态方法或类方法。它与非静态的方法的区别是：非静态方法的调用必须通过创建类的对象调用；而static方法则不需要、直接使用类名.静态方法名（）调用即可。
        static属性：可以不创建类的对象的而直接调用；另一个特征是：类的某一个对象的static属性值被改变后，这个类所有对象的static属性值都会被改变。


       c、super关键字：它与this相比较、指 的是当前类的的父类对象；可以用来实现父类中的方法重写。

       d、final关键字：当此关键字放在属性前面，属性的值就是常量、它的值就不可以改变；当放在方法的前面，其子类继承时、就不可以重写父类中的方法；所以常用来保护父类中不允许子类重写但有标识为public让外部调用的方法。


5、数组
    数组是java中最基本的一种数据结构，数组一旦定义、它的长度是一定的；
          其定义格式是：类型[]  数组变量名=new 类型[长度]；
          例：int[]  array=new int[30];
         也可以仅定义一个数组变量名，再来赋值；
          //定义一个int型的数组变量、并没有指向

    数组对象；
     int[] array;
     //将数组变量名指向一个数组对象
     array=new int [30];
     b、多维数组:
           格式如下：int[][]  array=new int[2][3];


6、队列
      队列的特点是先进先出；与数组不同的是队列没有长度限制；
    

[/align][align=center]