java基础语法（三）

数组

对数组的理解，我们可以把他认为一个容器，里面盛放多个相同数据类型相同的数据。数组的元素都是通过下标来访问的，下标是从0开始。

数组的使用

• 先创建，在赋值。

 int[]  array;array = new int[5];//需要注意要指定数组大小array[0] = 1;

• 创建带赋值

int[] array1 = new int[]{1,1,1,1,1,1};//创建带赋值

数组的遍历

 int[] array1 = new int[]{1,1,1,1,1,1};   for(int i = 0;i<array1.length;i++){   System.out.println(array1[i]);   }

需要注意的

1. 使用for循环遍历
2. 数组的下标是从0开始，所以从0开始遍历，最后的下标是数组长度减一。如果超过数组下标，会出现数组越界的错误。
3. 数组名.length是获取数组的长度.

方法

1、 访问修饰符：方法允许被访问的权限范围， 可以是 public、protected、private 甚至可以省略 ，其中 public 表示该方法可以被其他任何代码调用，

2、返回值类型：方法返回值的类型，如果方法不返回任何值，则返回值类型指定为 void ；如果方法具有返回值，则需要指定返回值的类型，并且在方法体中使用 return 语句返回值

方法的定义与调用

public class Java1 {   public static void main(String[] args) {     Java1 object = new Java1();     object.show();     }   public void show (){//中括号中是方法体 System.out.println("我是方法");   }}

在java中思想是面对象，所以在调用属性或者方法的时候，一定要构造对象。调用方法是通过对象.方法名()。

带返回值方法

 public int  sum() {   int a = 10;   return a;    }

注意点：

1. void和return是老死不相来往，有void的地方，就不能有return。
2. return只能返回一个值，不可以返回多个。
3. return之后返回对的数据类型必须和方法申明的返回类型一致。
4. 方法中执行的语句，必须都需要在return之前。

带参数的方法

public void show(String name){  System.out.println(name);   }

 public static void main(String[] args) {     Java1 object = new Java1();     object.show();     object.show("liushuai");     }

在这里补充一下啊，为什么我们执行方法，都必须是在main中，main是程序入口，都是从这里开始的。

通常我们在方法中传参数，在调用方法的时候，进行赋值。

方法的重载

 如果同一个类中包含了两个或两个以上方法名相同、方法参数的个数、顺序或类型不同的方法，则称为方法的重载，也可称该方法被重载了。如下所示 4 个方法名称都为 show ，但方法的参数有所不同，因此都属于方法的重载：

public void show (){System.out.println("我是方法");   }   public void show(String name){   System.out.println(name);   }

判断方法重载

1. 方法必须在同一个类
2. 方法名必须相同
3. 方法的参数类型，顺序，个数不同

执行方法时，是根据参数来选定方法的。

面向对象

定义类步骤

1.  定义类名
2. 定义类的属性
3. 定义类的方法

使用对象步骤

1.   类名  对象名 =  new 类名（）；
2.   对象名.属性

成员变量与局部变量

成员变量是定义在自己类中或者其他类中。作用域是这个类，直到类结束。成员变量不赋值，是有默认值。

局部变量定义在方法中，用来临时保存数据。作用域只是这个方法，其他方法不可以调用。局部变量是不会给默认值。你必须赋初始值，否则编译不通过。

构造方法

构造方法可以创建一个对象，并且可以初始化值。构造方法和类名一致，没有返回值。构造方法也是方法，如果有参数，就是有参构造方法，如果没有参数，我们称无参构造函数，系统默认给我们提供一个无参构造函数。

  public Java1(String name,int age){   name = name;   age = age;   }

此时用的是一个有参的构造函数，并且将传递的参数，赋给了当前的成员变量。

private int age;private String name;   public static void main(String[] args) {     Java1 object2 = new Java1("liu", 12);     System.out.println(object2.age+object2.name);     }

需要注意的一点，在你没有申明其他的构造函数，这时你用的系统的构造函数，但是如果你申明了其他构造方法，在想用系统的无参的构造函数一定要申明出来，否则不能调用无参函数

构造方法的重载同上面讲的方法重载基本一致。

在构造方法中可以进行值的判别

 public Java1(String name,int age){   name = name;   if(age<10){   System.out.println("输入值有误");   }else {   age = age;   }

静态变量   关键字 static

private static int age;

静态变量又成类变量，是属于某个类，可以直接用类名来调用变量。

 

补充，静态成员属于整个类，当系统第一次使用该类时，就会为其分配内存空间直到该类被卸载才会进行资源回收！~~

静态方法

public static void show3(){   System.out.println("静态方法");   }

注意点

1. 静态方法中可以直接调用同类的静态变量，但是不能调用非静态成员变量。
2. 如果在静态方法中，要调用非静态成员变量，可以通过在方法中创建类的对象，在调用。
3. 在普通的方法中可以调用同类的静态方法
4. 静态方法中，不能直接调用非静态的方法，如果需要，通过创建类对象来调用。

总之，上面一句话概括，静态的直接用过非静态不可以，但是非静态可以直接用静态。

静态代码块

public class Java2 {    public Java2(){    System.out.println("构造函数");    }    {    System.out.println("初始代码块");        }    static{    System.out.println("静态代码块");    }    public static void main(String[] args) {Java2 java2 = new Java2();Java2 java3 = new Java2();}}

通过上面代码测试，我们得知一下几个特性关于静态代码块:

1. 静态代码块是类加载的时候，就初始化，所以静态代码是最初执行，然后初始化代码块，最后构造函数。
2. 静态代码块只是在类第一次加载的时候执行，然后随便创建类对象，都不执行。

封装

概念:就是将类的信息隐藏类得内部，不允许外部直接去访问，而是通过该类提供的方法去实现隐藏信息的修改。

好处：只能通过规定方法去访问数据，隐藏类的实例细节，方便修改。

封装实现步骤:

1. 修改属性的可见性   用private关键字
2. 提供属性的set，get方法。
3. 在set get方法加入控制语句，进行值的合法性判断。

访问修饰符

作用:可以修饰属性方法的访问范围。

访问修饰符包括:

1. public 
2. protected
3. private
4. 默认 default

其中private的访问范围最小。

java中this关键字

this.属性  操作当前的对象属性

this.方法  操作当前的对象方法

内部类

定义在一个类内部，与之对应的，外部的，就称作外部类。

内部类的好处:

1. 内部类提供了更好的封装，不允许同一个包中的访问。
2. 内部类可以访问外部类的所有数据，包括私有属性。

内部类的类别:

1. 成员内部类
2. 静态内部类
3. 方法内部类
4. 匿名内部类

创建内部类的对象

先创建外部类对象

内部类  内部类名 = 外部类对象 .new 内部类();
        // 调用内部类对象的方法

外部类不能直接使用内部成员的方法属性，可以通过构建内部类的对象来访问。如果外部类和内部类具有相同的成员变量或方法，内部类默认访问自己的成员变量或方法，如果要访问外部类的成员变量，可以使用 this 关键字。this指的是当前对象，当前的对象是外部类的对象。

补充:需要注意的成员外部类  

静态内部类

静态内部类是 static 修饰的内部类，这种内部类的特点是：

1、 静态内部类不能直接访问外部类的非静态成员，但可以通过 new 外部类().成员 的方式访问 

2、 创建静态内部类的对象时，不需要外部类的对象，可以直接创建 内部类 对象名= new 内部类();