期末java复习

朴灿烈づ我的快乐病毒、 2023-10-03 10:36 34阅读 0赞

# 1.java程序设计基础 #

## 1.1 标识符、关键字及数据类型 ##

标识符：程序中的实体—变量、常量、方法、类和对象等的名称叫做标识符。

关键字：关键字又称作保留字，它们具有专门的意义和用途，不能当作一般的标识符使用。

数据类型：Java语言提供了丰富的数据类型，分为基本类型（又叫做原始类型）和引用类型两大类。

### 1.1.1 标识符 ###

程序中所用到的每一个变量、方法、类和对象的名称都是标识符（Identifier），都应该有相应的名称作为标识。简单地说，标识符就是一个名称。

**Java语言的标识符命名规则**

由英文字母A～Z或a～z、下划线（\_）、美元符号（$）和数字0～9组成，还可以包括中文字符等其他Unicode8.0字符集，开头必须是英文字母、下划线或美元符号（$）。 标识符区分大小写。如sum、Sum和SUM是三个不同的标识符。 不允许使用Java关键字（后面要介绍）来命名。 标识符没有长度限制，但我们不建议使用太长的标识符. 标识符命名原则应以直观且易于拼读为宜，即做到“见名知意” 。 Java中标识符命名约定：常量用大写字母，变量用小写字母开始，类以大写字母开始。 标识符不能包含空格，只能包含美元符（$）,不能包含\#、&、@等其它特殊字符。

# 2.类和对象 #

## 2.1 类的创建 ##

package sample;
    class StringTest{
        private String s;
        public void printString(){
            System.out.println(s);
        }
    
        public void changeString(String str){
            s = str;
        }
    
        public static void main(String[] args){
           StringTest st = new StringTest ();
           st.changeString("Hello Lixin");
           st.printString();
        } 
    }

## 2.2 类的定义 ##

基本语法如下： \[类修饰符\] class 类名称 \[extends 父类名称\]\[implements 接口名称列表\] \{ 成员变量定义及初始化； 方法定义及方法体； \} 类的定义由类声明和类体组成。其中，类声明包含关键字class、类名称及类的属性。 类的修饰符有：public、abstract 、final和friendly四种，默认方式为friendly。

## 2.3 成员变量的定义及修饰字 ##

成员变量：指类的一些属性定义，标志类的静态特征，它的基本语法如下： \[变量修饰符\] 变量数据类型 变量名1，变量名2\[=变量初值\]…; 对于一个成员变量，可以有访问说明符有public、private和protected三种： （1）public：省略时默认为公有类型，可以由外部对象进行访问。 （2）private：私有类型，只允许在类内部的方法中使用，若从外部访问，必须通过构造函数间接进行。 （3）Protected：受保护类型，子类访问受到限制。

## 2.4 方法的定义及修饰字 ##

基本格式如下： \[方法修饰符\] 返回类型 方法名称（参数1,参数2,…） \[throws 异常类\] \{ 方法体 \} 其中，方法修饰符有：\[public | protected | private \] \[static\] \[final | abstract\] \[native\] \[synchronized\]。

## 2.5 方法的参数传递 ##

### 2.5.1 参数的传递方式 ###

package sample;
    class ParamPass {
       void add(int i) {
         i += 5;
        }
    
       public static void main(String args[]) {
         int a = 10;
         System.out.println("a and b before call: " +a );
         ParamPass ob=new ParamPass();
         ob.add(a);
         System.out.println("a and b after call: " +a );
       }
    }

输出如下

> a and b before call: 10
> 
> a and b after call: 10

### **2.5.2 参数的引用方式**  ###

package sample;
    public class ParamPass {
    void changeArray(int[] array) {
          array[0] = 100;
          }
    public static void main(String args[]) {
          int array[] = new int[10];
          System.out.println("Before: Array[0] = " + array[0]);
          ParamPass ob=new ParamPass();
          ob.changeArray(array);
          System.out.println("After: Array[0] = " + array[0]);
          }
    }

输出如下

> Before: Array\[0\] = 0
> 
> After: Array\[0\] = 100

## 2.6 类的实例化 ##

### 2.6.1 创建对象 ###

对象的生成包括声明、实例化和初始化。基本语法如下： 类名称 对象名 //声明对象 对象名= new 类名（\[<参数列表>\]）； //创建对象

### 2.6.2 对象成员的使用 ###

对象的使用是通过运算符"."实现对变量的访问和方法的调用。变量和方法可以通过设定访问权限来限制其它对象对它的访问。基本语法如下： 对象名.成员变量名 对象名.成员方法名（\[<参数列表>\]）；

**【例】类的定义及成员方法的使用**

package sample;
    public class Person
    { 
      int age;
      public void pout()
       {
         System.out.println("My age is" + age);
        }
      public static void main(String  args[])
      {
        Person p1 = new Person();
        Person p2 = new Person();
        p1.age = 20;
        p2.age=18;
        p1.pout();
        p2.pout();
      }
    }

## 2.7 构造方法 ##

Java中的每个类都有构造方法，用来初始化该类的一个新对象。构造方法（Constructor）是一种特殊的方法。构造方法的**名称**必须和类名**相同**，为**公有类型**，**无返回值**，用来从类实例中访问类时初始化此类的私有变量。 当创建对象时，由new运算符调用默认构造方法（没有参数的构造方法）。但是特别要注意的是，如果程序中已经定义了构造方法，Java就不会再生成默认构造方法了。

## 2.8 继承的概念 ##

所谓继承就是保持已有类的特性而构造新类的过程。继承是子类利用父类中定义的方法和变量，就像它们属于子类本身一样。特殊类的对象拥有其一般类的全部属性与服务，称作特殊类对一般类的继承。例如：如汽车与小汽车；教育工作者与教师。当一个类拥有另一个类的所有数据和操作时，就称这两个类之间存在着继承关系。

> Java中不支持类之间的多重继承（注：Java支持接口之间的多重继承），即不允许一个子类继承多个父类。这是因为多重继承带来了许多必须处理的问题。多重继承只对编程人员有益，却增加了编译器和运行环境的负担。

## 2.9 多态性 ##

多态是指一个方法只能有一个名称,但可以有许多形态,也就是程序中可以定义多个同名的方法，用“一个接口，多个方法”来描述，可以通过方法的参数和类型引用实现。

多态的实现

package sample;
    public class ShapeTest {
     
      public ShapeTest() {  }
      public static void main(String[] args) {
        Shape[] s={new Shape(1,4),
                     new Rectangle(1,2,3,4),
                     new Circle(2,3,5)};
        for(int k = 0; k < s.length; k++){
            s[k].draw();
        }
      } 
    } 
    class Shape{
      protected int x;
      protected int y; 
      public Shape(){ }
      public Shape(int x, int y){
         this.x = x;
         this.y = y;
      }
     public void draw(){System.out.println("This is a test in shape.");}
    }
    class Rectangle extends Shape{
      private int heigth;
      private int weight;
      public Rectangle(int x, int y, int w, int h){
         super(x,y);
         this.weight = w;
         this.heigth = h;
      }
      public void draw(){System.out.println("This is a test in  Rectangle.");}
    }
    class Circle extends Shape{
      private int r; 
      public Circle(int x, int y, int r){
        super(x,y);
        this.r = r;
      }
      public void draw(){System.out.println("This is a test in Circle.");}
    }

# 3.Java面向对象高级特性 #

## 3.1 静态（static）变量、方法和初始化块 ##

类定义的内容主要包括成员变量、成员方法、构造方法和初始化块等，在定义方法和变量时，可以在之前用static修饰，表明它们是属于类的，称为静态方法（类方法）或静态变量（类变量）。

### 3.1.1 静态（static）变量 ###

用static修饰的成员变量称为静态变量（类变量），若无static修饰，则是实例变量。静态变量或类变量是一种全局变量，它属于某个类，不属于某个对象实例，是在各对象实例间共享。如果想访问静态变量可以直接通过类名来访问，可以不通过实例化访问它们。而实例变量就必须通过对象实例来访问它们。

class Example05_1 {
       int a = 1;
       static int b = 2;
    }
    class Example05_1Demo {
        public static void main(String args[]) {
         System.out.println("b=" + Example05_1.b);
         Example05_1.b *= 2;
         Example05_1 o1 = new Example05_1 ();
         o1.a = 10;
         System.out.println("o1.a="+ o1.a);
         System.out.println("b="+ o1.b);
         Example05_1 o2=new Example05_1 ();
         System.out.println("o2.a=" + o2.a);
         System.out.println("b="+ o2.b);
      }
    }

输出如下

> b=2
> 
> o1.a=10
> 
> b=4
> 
> o2.a=1
> 
> b=4

### 3.1.2 静态（static）方法 ###

同样，static修饰的成员方法称为静态方法（类方法），调用静态方法可以通过类名来调用，即不用实例化即可调用它们。 1、实例变量或者类变量在定义初始化时，都不能超前引用； 2、实例方法既可以使用实例变量，又可以使用静态变量；而静态方法只能使用静态变量，不能直接使用实例变量。

## 3.2 最终（final）类、变量和方法 ##

final在类之前，表示该类不能被继承，即final类不能作为父类，任何final类中的方法自动成为final方法，一个类不能同时用abstract和final修饰； final在方法之前，防止该方法被覆盖，final方法不能被重写，因此，如果你在子类中有一个同样签名的方法的话，你会得到一个编译时错误 final在变量之前，定义一个常量，一个final变量的值不能被改变，并且必须在一定的时刻赋值。

# 3.3 抽象方法与抽象类 #

Java中可以定义一些不含方法体的方法，它的方法体的实现交给该类的子类根据自己的情况去实现，这样的方法就是abstract修饰符修饰的抽象方法，包含抽象方法的类就叫做抽象类，也要用abstract修饰符修饰。

### 3.3.1 抽象方法 ###

用abstract来修饰一个方法时，该方法叫做抽象方法。形式如下： abstract \[修饰符\] <返回类型> 方法名称(\[参数表\]); 抽象方法并不提供实现，即方法名称后面只有小括号而没有大括号的方法实现。包含抽象方法的类必须声明为抽象类。抽象超类的所有具体子类都必须为超类的抽象方法提供具体实现。

### 3.3.2 抽象类 ###

抽象类通常包含一个或多个抽象方法（静态方法不能为抽象方法）。  抽象类必须被继承，抽象方法必须被重写；  抽象类不能被直接实例化。因此，它一般作为其他类的超类，使用抽象超类来声明变量，用以保存抽象类所派生的任何具体类的对象的引用。程序通常使用这种变量来多态地操作子类对象。与final类正好相反；  抽象方法只需声明，而无需实现。定义了抽象方法的类必须是用abstract修饰的抽象类。

## 3.4 接口（interface） ##

通过接口可以实现不相关类的相同行为，而无需考虑这些类之间的层次关系； 通过接口可以指明多个类需要实现的方法； 通过接口可以了解对象的交互界面，而无需了解对象所对应的类。

### 3.4.1 接口的定义 ###

在java中，接口是由一些常量和抽象方法所组成，接口中也只能包含这两种东西，一个接口的声明跟类的声明是一样的，只不过把class关键字换成了interface

### 3.4.2 接口的实现 ###

实现接口我们使用implements关键字。在子类中可以使用接口中定义的常量，而且必须实现接口中定义的所有方法，否则子类就变为抽象类了。

1、接口中的常量必须是用public static final修饰；

2、接口中的方法必须用public static修饰；

## 3.5 内部类 ##

Inner Class按照字面意思就是内部类的意思，简单说就是嵌套在另一个类中定义的类就是内部类（Inner Classes）。包含内部类的类叫做外部类。

Inner Class可以直接访问外部类的成员。因为Inner Class在外部类中，理所当然可以访问任何的成员，包括声明为private的成员。