数组及其封装的理解

数组：
 数组是储存同一种数据类型的容器。
 数组的定义：
 数据类型[] 数组名;//int[] a;
 数据类型 数组名[];//int a[];
 数组的初始化：
 1、动态初始化：数据类型[] 数组名=new 数据类型[数组长度];

//int[] arr=new int[3];

 2、静态初始化：给定数组中元素的值，数组的长度有系统给定。

//int[] arr={1,2,3};

  如何获取数组中的元素
  
    获取数组中的元素:通过数组名称获取
  格式:
    数组名称[索引值],数组的索引值从0开始,最大的索引=数组长度-1
 数组中经常会出现的异常：
  ArrayIndexOutOfBoundsException:数组角标越界异常
      出现的原因:访问了数组中不存在的索引值;
     解决方案:观察数组中到底有索引值到多少;  数组长度-1
    NullPointerException:空指针异常 (在实际开发中该异常是最多的)
      出现的原因:对象为null,而开发者还要去使用对象,就会出现问题
      解决方案:给某个对象进行非空判断,防止程序程序空指针异常
 OOM异常:OutOfMemory:内存溢出   Android 解决加载大量图片的问题:图片加载器:ImageLoader等等
数组的应用：
 遍历一个数组：

package com.practice01;
public class Dometext01 {
 public static void main(String[] args) {
  int[] arr= {45,62,75,52,65,54};
  user(arr);
 }
 public  static void user(int arr[]){
  System.out.print("[");
  for(int i=0;i<arr.length;i++) {
   if(i==arr.length-1) {
    System.out.print(arr[i]+"]");
   }else {
    System.out.print(arr[i]+", ");
   }
  }
 }
}

 数组中元素的逆序：

package com.practice01;
public class Demotext03 {
public static void main(String[] args) {
 int[] arr= {56,25,52,75,62,85};
 user(arr);
 user1(arr);
}
public static void user(int[] arr) {
 for(int i=0;i<arr.length/2;i++)
 {
  int temp=arr[i];
  arr[i]=arr[arr.length-1-i];
  arr[arr.length-1-i]=temp;
 }
}
public  static void user1(int arr[]){
 System.out.print("[");
 for(int i=0;i<arr.length;i++) {
  if(i==arr.length-1) {
   System.out.println(arr[i]+"]");
  }else {
   System.out.print(arr[i]+", ");
      }
 }
 
   }
} 

数组中的元素查找法：

package com.practice01;
import java.util.Scanner;
public class Demotext04 {
public static void main(String[] args) {
     int[] arr= {23,43,54,32,53,24};
     Scanner cs=new Scanner(System.in);
     System.out.println("请输入数组中的一个数字：");
     int number=cs.nextInt();
     int index=fing(arr,number);
 System.out.println(number+"的索引是："+index);
 
 }
public static int fing(int[] arr,int value) {
     for(int i=0;i<arr.length;i++) {
      if(arr[i]==value) {
       return i;
     }
 }
       return -1;
    }
}

面向对象：
 面向对象：就是让你去创建一个对象，然后让对象帮你去执行，你不用去参与过程，最终获取结果就可以了。
 1）首先创建一个（例如：学生）学生类
 2）然后定义一些成员变量（例如学生的属性：姓名、年龄、学号等等）
 3）然后也可以在定义一些成员方法（例如：打游戏、去运动等等）
然后在（main）主函数里
 1）首先去创建一个学生类的学生对象；（例如：student s=new student(）)
 2）然后给前面的学生类中的成员变量进行赋值；
    去输出他们。
 3）也可以去调用学生类中的成员方法。
形式参数的问题：

 class Demo{
 
 //求和的成员方法
 public int sum(int a,int b) { //形式参数是基本类型，那么它的改变对实际参数没有影响；
     //如果是引用类型，那么形式参数的改变会直接影响实际参数
 }
}

匿名对象：
 就是在创建对象的时候，没有名字的对象。
  匿名对象在实际开发中只使用一次，不要使用多次（可能会造成内存溢出的现象）
 例如：正常创建一个学生类对象是：student s=new student（）；
  匿名对象就是直接是：new student（）；//这样会不断的扩展堆内存。
封装：
 就是将类中的成员变量通过private私有化，从而使外界无法调用
 private的用法:
  1)被private修饰的只能在本类中访问
  2）可以通过公共的访问public去间接访问
 当成员变量和局部变量名称一致时，采取就近原则 
 当成员变量被私有化时，也可以通过setxxx/getxxx的方式进行输出（快捷键是shift+alt+r+s）
  然后在主函数中进行赋值，并且输出。

       
例如：

package com.text01;
class student{
 private String name;
 private int age;
 private String Id;
 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 getId() {
  return Id;
 }
 public void setId(String id) {
  Id = id;
 }
 
}
public class Dome03 {
public static void main(String[] args) {
 student s=new student();
 s.setName("迪丽热巴");
 s.setAge(24);
 s.setId("132614");
 System.out.println(s.getName()+"----"+s.getAge()+"----"+s.getId());
}
}

构造方法：
 就是给对象进行初始化。
 构造方法：1）方法名和类名相同 2）构造方法中没有void
 构造方法的注意事项：
  1）之前没有写无参构造，系统会默认提供无参构造
  2）如果我们写无参构造或者有参构造，系统不会在提供无参构造；定义一个类的时候，永远给出无参构造
 构造方法是可以重载的
  重载就是方法名相同，方法的类型和类型数量不同。
例如：

package com.text01;
class header{
 private String name;
 private int age;
 public header() {
  
 }
 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 header(String name,int age) {
  this.name=name;
  this.age=age;
  System.out.println("这是一个带有俩个类型的变量");
 }
 
 
}
public class Dome04 {
public static void main(String[] args) {
 header t=new header();
 //通过setxxx和getxxx方法进行赋值
 t.setName("迪丽热巴");
 t.setAge(25);
 System.out.println(t.getName()+t.getAge());
 System.out.println("-----------");
 //通过有参构造进行赋值
 header t2=new header("迪丽热巴",25);
 System.out.println(t2.getAge()+t2.getName());
}
}

当进行运算的时候往往是先运算有参构造。
成员方法的分类：
 1）按照返回值划分
  void的形式：没有具体的返回值
  非void的形式：有具体的返回值
 2）按照参数进行划分
  空参
  有参
例如：

package com.text01;
class bool{
     private String name;
     private String age;
     public bool() {
  
 }
 
 //无参有返回值的
 public String method() {
      return "hello baby";
 }
 //无参没返回值的
 public void method1() {
      System.out.println("ainio"); 
 }
 //有参无返回值
 public void fuck() {
      System.out.println("fuck you");
 }
 //有参有返回值
     public String fuck2(String s1,String s2){
          return s1+s2;
 }
 
}
public class Dome05 {
 public static void main(String[] args) {
      bool t=new bool();
      String s=t.method();//当有返回值的时候建立方法对象，从而输出它
      System.out.println(s);
      t.method1();
      t.fuck();
      String d=t.fuck2("25", "32");
      System.out.println(d);
 }
}

当无参构造被私有化时，可以通过类名+方法名进行访问。

static关键字：
 当多个对象对同一个变量进行共享时，这时就需要static：静态的（共享的）
 在方法区中：开辟一个静态区域：都是静态标记
例如：

package com.text01;
class girl{
     String name;
     int age;
     static String country;//当国家是需要共享的时候，用static关键字修饰
 public girl() {
  
 }
 public girl(String name,int age,String country) {
      this.name=name;
      this.age=age;
      this.country=country;
 }
 public girl(String name,int age) {
      this.name=name;  //在这里再定义一个俩种类型的有参构造
      this.age=age;
 }
 public void show() {
      System.out.println(name+age+country);
 }
}
    public class Dome07 {
public static void main(String[] args) {
     girl g=new girl("西施",24,"中国");
     g.show();
     girl g1=new girl("杨贵妃",25);
     g1.show();
     girl g2=new girl("迪丽热巴",24);
     g2.show();
     g1.country="加拿大";//在这里将变量的值改变后，输出的三个国家的值都将发生改变
     g.show();
     g1.show();
     g2.show();
}
}

static用法:
 
    一个类中可有静态变量,也可以有非静态
      可以有静态成员方法,也可以非静态的成员方法
       静态的方法只能访问静态变量,或者是静态的方法
       非静态的方法,既可以访问静态变量也可以非静态的变量...
 
    静态只能访问静态，静态是不可以访问非静态中的方法