JAVA数组和面向对象

(一)数组

• 数组:可以存储多个元素并且多个元素是 同一种类型的容器

  数组的 定义:
  数据类型[] 数组名;
  数据类型 数组名[];

  举例:
  int[] a; 定义了一个int类型的数组变量a
  int a[] ; 定义了一个int类型 变量a数组

  这两种方式的定义:虽然写法不一样,并且读法不一样,但是表达的效果一样,都是在定义一个数组,推荐使用第一种方式;

  数组的初始化:
  1)动态初始化: 给数组指定长度,数组中的元素值由系统默认给定
  2)静态初始化: 给定数组中元素的值,数组的长度由系统给定;

  动态初始化:
  数据类型[] 数组名 = new 数据类型[数组长度] ;

  静态初始化:
  指定数组的元素,长度由系统给定
  定义个数:
  原始格式:
  数据类型[] 数组名称 = new 数据类型[]{元素1,元素2,元素3....} ;
  简写方式:
  数据类型[] 数组名称= {元素1,元素2,元素3..} ;

  注意：数组中经常会出现的异常:
  ArrayIndexOutOfBoundsException:数组角标越界异常
  出现的原因:访问了数组中不存在的索引值;
  解决方案:观察数组中到底有索引值到多少; 数组长度-1
  NullPointerException:空指针异常 (在实际开发中该异常是最多的)
  出现的原因:对象为null,而开发者还要去使用对象,就会出现问题
  解决方案:给某个对象进行非空判断,防止程序程序空指针异常

  (二)面向对象

1、讲面向对象之前:
面向过程:
假设有一个需求:求数组中的最大值;
定义一个数组,静态初始化---->定义一个参照物---->遍历....
给一个需求,对需求分析,然后一步一步进行操作,最终得到某一个结果,整个过程都是自己在完成....

面向对象的思想概述:
思想的特征:
1)面向对象更符合我们的生活中的行为思想习惯
2)面向对象将我们从执行者变成了指挥者,指挥对象做事情
3)面向对象简单性体现在这里:让我们事情从复杂性--->简单化

    举例:
        洗衣服:
            面向过程:脱下脏衣服--->放到一个盆里面--->加水,洗衣液---->泡一泡--->搓一搓---->拧一拧----->
        晾一晾
            面向对象:脱下脏衣服--->放到一个全自动洗衣机中--->一键---->晾一晾

        炒菜:
            面向过程:买菜--->摘菜--->洗菜--->切菜--->炒菜--->出锅
            面向对象:找一个对象..--->出锅...

举例:
把大象装进冰箱

    1)装大象的方法in()
    2)开冰箱门:open()
    3)关闭冰箱门:close()
        面向过程:
        class Test{

            main(..){
                //分别调用三个方法
                open();
                in();
                close();
            }

            //开冰箱门
            public static void open(){
                System.out.println("开冰箱门...") ;
            }
            //装大象
            public static void in(){
                System.out.println("把大象塞进冰箱") ;
            }

            //关闭冰箱门
            public static void close(){
                System.out.println("开冰箱门...") ;
            }
        }

面向对象:
        把大象装进冰箱 :   名词提取法:  大象类,冰箱类,测试类

        class 大象类{
            public static void in(){
                System.out.println("把大象塞进冰箱") ;
            }
        }

        class 冰箱类{
            public static void open(){
                System.out.println("开冰箱门...") ;
            }

            public  static  void close(){
                System.out.println("开冰箱门...") ;
            }
        }

        class Test{
            main(){

                类名.方法名() ;
                大象类.in() ;
                冰箱类.open();
                并迅雷.close() ;

            }
        }

面向对象的三大特征:
封装
继承
多态
向对象语言中现实世界的事物在代码中如何体现的{

学生
    属性:姓名 年龄 性别 ...学号
    行为:学习,打游戏....

学生现实世界的事物------>代码 学生类:Student
属性:属性:姓名 年龄 性别 ...学号 成员变量:name,age,sex...
行为:学习,打游戏.... 成员方法:study(),playGame();

总结:
        面向对象
                :将事物看成XX类,将事物对应的属性--->看成这个类的成员变量
                    将事物对应的行为----->看成这个类的成员方法

描述一个学生事物,
属性:姓名,年龄,性别,学号
行为:学习

在Java中,创建对象:new对象
类名 对象名 = new 类名() ;
public class Student {

//成员变量
String name ;
int age ;
String gender ;
int Id ;

//成员方法:学习的方法
//先去掉static
public void study() {
    System.out.println("学生在学习Java.....") ;
}

}
}

public class StudentTest {

public static void main(String[] args) {

    //创建一个学生对象

// 格式: 类名 对象名 = new 类名() ;
Student s = new Student() ;
//System.out.println(s);//org.westos.oop.Student@70dea4e 包名.类名@(地址值标记)16进制数据
System.out.println("学生的姓名是:"+s.name+",年龄是:"+s.age+",性别是:"+s.gender+",学号是:"+s.Id);

    //给学生对象进行赋值
    s.name = "张三" ;
    s.age = 21 ;
    s.gender = "男" ;
    s.Id = 007 ;
    System.out.println("学生的姓名是:"+s.name+",年龄是:"+s.age+",性别是:"+s.gender+",学号是:"+s.Id);

    //调用Student类中的成员方法
    //对象名.成员方法名() ;
    s.study(); 

}

}
2、匿名对象
就是创建对象的时候,没有名字的对象
例如：
创建一个有名字的学生类对象
Student s = new Student() ;//该对象名s
匿名对象(开发中经常使用),没有名字的对象
new Student().name = "赵又廷" ;
匿名对象在实际开发中,只用使用一次,不要使用多次 (可能会造成一个内存溢出的现象);
new Student() ; //一直给堆内存开辟空间
3、形式参数
形式参数的问题:
如果是基本数据类型,形式参的改变对实际参数没有影响
研究引用类型:形式参数的改变会直接影响实际参数
例如：
class Demo{

//求和的成员方法
public int sum(int a,int b) { //形式参数是基本类型  :
    return a+b ;
}

}

//一个学生类
class Student{
public void show() {
System.out.println("好好学习,天天向上....");
}
}

class StudentDemo{
//method方法中形式参数是一个引用类型:需要的是学生类对象 Student s = new Student () ;
public void method(Student s) {//形式参数现在引用类型
s.show();
}
}

//测试类
public class ArgsTest {

public static void main(String[] args) {
    //创建Demo类对象
    Demo d = new Demo() ;
    System.out.println(d.sum(10, 20)) ;
    System.out.println("-------------------------");

    //需求:调用StudentDemo中的method方法:如何调用
    //1)创建StudentDemo类对象
    StudentDemo sd = new StudentDemo() ;
    //2)形式参数是Student类型,所以创建Student类的对象
    Student s = new Student() ;
    sd.method(s);

}

}
4、private关键字
private的用法：
1）被private修饰的只能在本类中访问
2）可以通过公共的访问public 去间接访问

当成员变量和局部变量一致时，遵循就近原则。
列如：
class Phone{
//私有修饰
        private String brand ;
        private int price ;
        private String color ;

//成员方法
//提供公共的访问方法
public void setBrand(String brand) {
        brand = brand ;
}

//获取手机品牌
public String getBrand() {
        return brand ;
}

public void setPrice(int p) {
    price = p ;
}
public int getPrice() {
    return price ;
}

public void setColor(String c) {
    color = c ;
}
public String getColor() {
    return color ;
}

}

//测试类
public class PhoneDemo {

public static void main(String[] args) {

    //创建手机类对象
    Phone p = new Phone() ;

// p.brand = "" ; 已经被私有化了
// System.out.println(p.brand+"----"+p.price+"---"+p.color);
p.setBrand("小米");
p.setPrice(1699);
p.setColor("黑色");
System.out.println(p.getBrand()+"---"+p.getPrice()+"----"+p.getColor());

}

}
成员变量:姓名和年龄
测试这个学生类

分析:
刚才通过下面代码给学生的年龄赋值了一个不合理的数据,而这种不合理的数据依然可以被输出出来,有问题!
解决方案?
在Student类中提供一个针对年龄的判断的一个方法

    虽然提供了这一个方法,但是成员变量在测试类中永远被访问到,针对这种情况:Java提供了关键字:private:私有的

private:体现的也是一种封装思想
封装:
标准类的写法,将成员变量全部私有化,被private修饰的成员变量只能在本类中访问,可以通过公共的访问方法去访问成员变量
5、构造方法以及创建对象的过程
一个标准类的写法:
学生类
成员变量:姓名,年龄,性别
成员方法:set/getXXX()
学习,睡觉...

构造方法:
            无参构造:
            有参构造

一个标准手机类的写法:
class Student{
//成员变量
private String name ;
private int age ;
private char gender ;

//无参构造方法
public Student() {}

//有参构造
public Student(String name,int age,char gender) {
    this.name = name ;
    this.age = age ;
    this.gender = gender ;
}

//setXXX/getXXX()方法
public void setName(String name) {
    this.name = name ;
}
public String getName() {
    return name ;
}
public void setAge(int age) {
    this.age= age;
}
public int getAge() {
    return age ;
}

public void setGender(char gender) {
    this.gender= gender ;
}
public char getGender() {
    return gender ;
}

//学习
public void study() {
    System.out.println("学生在学习...");
}
public void sleep() {
    System.out.println("学生困了,就需要睡觉...");
}

}

//测试类
public class StudentDemo {
public static void main(String[] args) {

    //方式1:创建学生类对象
    //无参构造+set/getXXX()相结合的方式
    Student s = new Student() ;
    s.setName("高圆圆");
    s.setAge(28);
    s.setGender('女');
    System.out.println(s.getName()+"----"+s.getAge()+"---"+s.getGender());
    System.out.println("----------------------------");

    //方式2:直接通过有参构造形式
    Student s2 = new Student("高圆圆", 27, '女') ;
    System.out.println(s2.getName()+"----"+s2.getAge()+"---"+s2.getGender());

}

}
6、static关键字
（1） 定义一个人类
成员变量:姓名 年龄 国籍
创建了三个Person对象,每一个对象的国籍都是中国,值是重复的,这样的话在堆内存中比较浪费内存空间,不好
针对这种情况,多个对象对同一个变量进行共享,这个时候Java提供了一个关键字---static: 静态的(共享的)
在方法区中:开辟一个静态区域: 都是静态标记
（2） 关于static关键字:

    1)静态随着类的加载而加载
    2)static优先于对象存在
        回想:main  public static void main(..){...}

    3)static共享数据,可以被多个对象进行共享
        举例: 饮水机(staticd的:共享的)
                水杯(不能共享的...)
    4)如果数据被静态修饰的,它可以被类名直接调用
                被静态修饰的方法:   类名.方法名()
                被静态修饰的变量:   类名.变量名;

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

            简单记:静态只能访问静态

7、this关键字
定义变量,方法,类,接口,做到见名知意
在手机类中的公共的访问方法中,对应局部变量名称应该做到见名知意
虽然做到见名知意了,但是局部变量将成员变量可以隐藏掉,Java提供一个关键字:this
this:代表是当前类对象,或者是(当前类对象的引用),解决局部隐藏了成员变量
例如：
class Phone{

//私有修饰
private String brand ;
private int price ;
private String color ;

//成员方法
//提供公共的访问方法
public void setBrand(String brand) {

// brand = brand ;
this.brand = brand;
}

//获取手机品牌
public String getBrand() {
    return brand ;
}

public void setPrice(int price) {

// price = price ;
this.price = price ;
}
public int getPrice() {
return price ;
}

public void setColor(String color) {
    //color = color ;
    this.color = color ;
}
public String getColor() {
    return color ;
}

}

//测试类
public class Test {

public static void main(String[] args) {

    //创建手机类对象
    Phone p = new Phone() ;
    p.setBrand("华为");
    p.setPrice(1999); 
    p.setColor("黑白");

    System.out.println(p.getBrand()+"---"+p.getPrice()+"----"+p.getColor());
    System.out.println("-----------------------");

    Student s = new Student() ;
    s.setName("高圆圆");
    s.setAge(28); 
    s.setsId("xx002");
    s.setGender('女');
    s.setTitle("学习委员");

    System.out.println(s.getName() + "----" + s.getAge() + "----" + s.getsId() + "----" + s.getGender() + "----"
            + s.getTitle());
}

}
8、类的组成中有一个成员：成员方法
成员方法的分类:
1)按照返回值划分
void的形式:没有具体的返回值
非void形式:有具体返回值
2)按照参数进行划分
空参
有参
//创建一个学生类
class Student {

private String name ;
private String age ;

public Student() { //alt+shift+s+c
}

//成员方法
public String show() { //有返回值没有参数的
    return "helloworld" ;
}

//没有返回值,有参数的情况
public void method(String s) {
    System.out.println(s);
}

//没有返回值,没有参数的情况
public void function() {
    System.out.println("function student...");
}

//有返回值,有参数的情况
public String function2(String s1,String s2) {
    return s1+ s2;
}

}

//测试类
public class Test {

public static void main(String[] args) {

    //创建学生类对象
    Student s = new Student() ;

    String str = s.show() ;
    System.out.println(str);
    s.method("Java");
    s.function();
    String str2 = s.function2("hello", "world") ;
    System.out.println(str2);

}

}
9、构造方法
构造方法作用:
就是给对象进行进行初始化
构造方法也属于一类的组成:
成员变量
构造方法
成员方法
构造方法:
1)方法名和类名相同
2)构造方法,连void都没有
构造方法的注意事项:
1)之前没有写无参构造,系统会默认提供无参构造
2)如果我们无参构造或者有参构造,系统不会在提供无参构造;定义一个类的时候,永远给出无参构造;
构造方法是可以重载的:

转载于:https://blog.51cto.com/13670525/2097159