Java第六章总结

面向对象概述

1. 对象

现实世界中，随处可见的一种事物就是对象。对象是事物存在的实体，如人，课桌高楼大厦等等。通常对象会被分为两个部分：即静态部分与动态部分。顾名思义，静态部分就是不能动的部分，这个部分被称为“属性”，任何对象都会具备其自身属性，动态部分即对象可执行的动作，这部分称为“行为”

2.类

类时对象的设计图

不能将一个事物描述成一类事物，如一只鸟不能称为鸟类。但如果要给某一类事物一个统称，就需要用到类这个概念。

类是封装对象的属性和行为的载体，具有相同属性和行为的一类实体被称为类。

在Java语言中，类对象的行为是以方法的形式定义的，对象的属性是以成员变量的形式定义的，所以类包括对象的属性和方法

3.封装

封装提高代码的复用性

面向对象程序设计具有以下特点：封装性，继承性和多态性。

封装是面向对象编程的核心思想。将对象的属性和行为封装起来，其载体就是类，类通常对客户隐藏其实现细节，这就是封装的思想。

采用封装的思想保证了类内部数据结构的完整性，使用类的用户不能轻易地直接操作类的数据结构，只能执行类允许公开的数据。这样就避免了外部操作对内部数据的数据，提高了程序的可维护性。

4.继承

类与类之间具有关系，这种关系被称为关联。关联主要描述两个类之间的一般二元关系，例如：学生类与教师类也是一个关联。两个类之间的关系有很多种，继承是关联中的一种。

当处理一个问题时，可以将一些有用的类保留下来，在遇到同样的问题时拿来复用。

设计软件时，使用继承思想可以缩短软件开发的周期，复用那些定义好的类可以提高系统性能，减少系统在使用过程中出现错误的概率。

继承性主要利用特定对象之间的共有属性。如四边形和正方形，矩形这些都是四边形，平行四边形与四边形类具有共同特性，就是拥有4个边。在Java中将类似平行四边形的类称为子类，将类似四边形类的被称为父类或超类。子类可直接使用父类代码。

5.多态

多态表现出不同的形态

将父类对象应用于子类的特征就是多态。

多态性允许以统一的风格编写程序，以处理种类繁多的已存在的类以及相关类。该统一风格可以由父类来实现，根据父类统一风格的处理，可以实例子类的对象。由于整个事件的处理都只依赖于父类的方法，所以日后只要维护和调整父类的方法即可。这样就降低了维护的难度，节省了时间。

类

1. 成员变量

在Java中对象的属性也称为成员变量，成员变量可以是任意类型，整个类中均是成员变量作用范围。

public class Book {//类 

    public String name;//String类型的成员变量
    public String getName() {//name 的Getter方法
        return name;
    }
    public void setName(String name) {//name的Setter方法
        this .name=name;//将参数值赋予类中的成员变量
    }
}

2. 成员方法

在Java中，使用成员变量方法对应于类对象的行为。语法格式如下：

权限修饰符，返回值类型，方法名（参数类型 参数名）{
… //方法体
return 返回值;
}

3.权限修饰符

Java中的权限修饰符主要包括public、protect、default、private,这些修饰符控制着对类和类的成员变量以及成员方法的访问。

要是有很多个要设置的话就会非常麻烦，那么只要使用编译器就会很方便。操作如下。

这样就快速弄好了。

快速方法构造：

这样就可以直接使用了

4.局部变量

如果在成员方法内定义一个变量，那么这个变量被称为局部变量。在实际上，方法中的形参也可以作为一个局部变量。

局部变量是在方法被执行时创建，在方法执行结束时被销毁。局部变量在使用时必须进行赋值操作或被初始化，否者会出现编译错误 。

在part类中创建静态的exchange（）方法，该方法可以将数组参数arr的前两个元素值互换，通过在方法中定义一个保存临时数据的局部变量tmp,利用tmp交换两个元素的值。

public class ChanggeDemo {
    public static int[] exchange(int[] arr) {
        int tmp=arr[0];//创建局部变量tmp，保存数组第一个元素的值
        arr[0]=arr[1];//第二个元素赋值给第一个元素
        arr[1]=tmp;//第二个元素值改为tmp
        return arr;
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int arr[]= {17,29};
        System.out.println("第一个值="+arr[0]+",第二个值="+arr[1]);
        arr=exchange(arr);
        System.out.println("第一个值="+arr[0]+",第二个值="+arr[1]);
    }

}

结果如下：

5.局部变量的有效范围

可以将局部变量的有效范围称为变量的作用域，局部变量的有效范围从该变量的声明开始到该变量的结束为止。

6.this关键字

this关键字用于表示本类当前的对象，当前对象不是某个new出来的实体对象，而是当前正在编辑的类。this关键字只能在本类中使用。

public void setName(String name) {//定义一个setName（）方法
        this .name=name;//将参数值赋予类中的成员变量
    }

this可以调用成员变量和成员方法还可以作为方法的返回值。

类的构造方法

在类中，出成员方法外，还存在一种特殊类型的方法，那就是构造方法。构造方法时一个与类同名的方法，对象的构建就是通过构造方法完成的。每当类实例化一个对象时，类都会自动调用构造方法。

构造方法的特定如下：

构造方法没有返回值

构造方法的名称要与本类的名称相同。

构造方法的定义语法格式如下：

public Book(){
… //构造方法体
}

public:构造方法修饰符

Book：构造方法的名称

在构造方法中可以为成员变量赋值，这样当示例化一个本类对象时，相应的成员变量也将被初始化。如果类中没有明确定义构造方法，编译器会自动创建一个不带参数的默认构造方法。

public class EggCake {
    int eggCount;//鸡蛋灌饼里蛋的个数
    public EggCake( int eggCount) {//参数为鸡蛋灌饼里蛋的个数的构造方法
        this.eggCount= eggCount;//将参数 eggCount的值付给属性 eggCount
    }
    public EggCake() {//无参数构造方法，默认给饼加一个蛋
        //调用参数为鸡蛋灌饼里蛋的个数的构造方法，并设置鸡蛋灌饼里蛋的个数为1
        this(1);
    }
    
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        EggCake cake1=new EggCake();
        System.out.println("顾客不要求加蛋的数量，饼里会有"+cake1.eggCount+"个蛋");
        EggCake cake2=new EggCake(2);
        System.out.println("顾客要求加2个蛋，饼里会有"+cake2.eggCount+"个蛋");
    }

}

结果如下：

静态变量和静态方法

在静态变量和静态方法之前，static关键字，因为由于static修饰的变量和方法被称为静态变量和静态方法。被声明为static的变量的方法被称为静态成员。静态成员属于类所有，区别于个别对象，可以在本类或其他使用类名和“.”运算符调用静态成员。

public class StaticDemo {
    //静态变量
    static double Pl=3.1415926;//在类中定义静态变量
    //常量
    static final int i=3;//在类中定义静态常量
    //final:常量(最终的，最后的)/最后一次赋值
    static void method() {//在类中定义静态方法
        System.out.println("这是静态方法");
        
    }
    //静态代码块
    static
    {
    //1
        //2
        //3
        //4
        //5
    }
    public static void main (String []args) {
        System.out.println(StaticDemo.Pl);//调用静态变量
        System.out.println(StaticDemo.i);//调用静态常量
        StaticDemo.method();//调用静态方法
    }
}

结果如下：

静态变量与静态方法的作用通常是为了提供了共享数据或方法，如数学计算公式等，尽管使用这种方法调用静态成员比较方法方便，但静态成员同样遵循着public，private，和protected修饰符的约束。

在Cust类中创建一个静态整数类型属性count ,在构造方法中让count自增：

public class Cust {//顾客类
        static int count=0;//共享的属性：人数
        String name;//名称属性
        public Cust(String name) {
            this.name=name;//记录名称
            count++;//人数递增
        }

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Cust c1=new Cust("tom");
        System.out.println("我是第"+Cust.count+"名顾客，我叫"+c1.name);//输出
        Cust c2=new Cust("张三");
        System.out.println("我是第"+Cust.count+"名顾客，我叫"+c2.name);
        Cust c3=new Cust("狗蛋儿");
        System.out.println("我是第"+Cust.count+"名顾客，我叫"+c3.name);

    }

}

结果如下：

总结以下使用static关键字要注意的几点：

在静态方法中不可使用this关键字。

在静态方法中不可以直接调用非静态方法。

局部变量不可以使用static关键字声明。

主方法必须用static声明。

只有内部类可以使用static关键字声明。

类的主方法

主方法是类的入口点，它定义了程序从何处开始。主方法提供对程序流向的控制，Java编译器通过主方法来执行程序。主方法语法如下：

public static void main(String[] args) {
… //方法体
}

在主方法的定义中可以看到其具有以下特性：

• 主方法是静态的，所以如要直接在主方法中条用其他方法，则该方法必须也是静态的。

• 主方法没有返回值。

• 主方法的形参为数组。其中，args[0]~[n]分别代表程序的第一个参数到n个参数，可以使用args.length获取参数的个数。

public class MainDemo {

    public static void main(String[] args) {//定义主方法
        // TODO Auto-generated method stub
        for(int i=0;i<args.length;i++) {//根据参数个数做循环操作
            System.out.println(args[i]);//循环打印参数内容
        }
    }

}

结果如下：

在代码运行前先设置参数，进行以下操作：右击界面

输入相应的参数，每个参数间按Enter键隔开。

对象

使用new操作符调用构造方法创建对象：

Test test=new Test（）；
Test test=new Test（“a”）；

设置值	描述	设置值	描述
Test	类名	new	创建对象操作值
test	创建Test类对象	"a"	构造方法的参数

test对象被创建出来时，就是一个对象的引用，这个引用在内存中为对象分配了存储空间

package a;
 
public class b {  
 String name;
 int age;
 String sex;
 public b() {
  
 }
 public b(String name,int age,String sex) {
  this.name=name;
  this.age=age;
  this.sex=sex;
  
 }
 public static void main(String []args) {
  b p1=new  b("tom",23,"男");
  b p2=new b("lily",19,"女");
  
 }
 
}

package Dog;
 
public class Dog{  
 String name;//名字
 String color;//颜色
 String vioce;//叫声
 
 public Dog(String name,String color,String vioce) {
  this.name=name;
  this.color=color;
  this.vioce=vioce;
  
 }
 public void call() {//叫
  System.out.println(vioce);
 }
 public static void main(String []args) {
  Dog d1=new  Dog("毛毛","白色","汪汪汪");
  System.out.print(d1.name+"的颜色是"+d1.color);//访问对象的属性
  System.out.print("叫起来的声音：");
  d1.call();//访问对象的行为
  Dog d2=new Dog("灰灰","灰色","嗷呜~");
  System.out.print(d2.name+"的颜色是"+d2.color);
  System.out.print("叫起来的声音：");
  d2.call();
  
 }
 
}

结果如下：

引用

真正的操作标识符实质上是一个引用，引用的语法

类名 对象的引用变量

例如，一个people类的引用可以使用以下代码：

people tom；

通常一个引用不一定需要有一个对象相关联。

people tom=new people();

对象的销毁

每个对象都有生命周期，当对象的生命周期结束时，分配给该对象的内存地址需要被回收在其他语言中，需要用户手动回收废弃的对象，JAVA拥有一套完整的垃圾回收机制，用户不必担心废弃的对象占用内存，垃圾回收器会自动回收无用却占用内存的资源

怎么判断对象会被JAVA虚拟机视为垃圾？主要包括两种情况

将对象赋值为null

虽然JAVA的垃圾回收机制已经很完善，但垃圾回收只能回收那些由new操作符创建的对象

某些对象不是通过new创造并获得存储空间的这些对象是无法被垃圾回收机制所识别

finalize（）

那么JAVA提供了一个finalize方法

这个方法是object类方法，他被声明为protected，用户可以在自己的类中定义这个方法，定义了这个方法后，垃圾回收时会首先调用该方法

system.gc()

由于垃圾回收不受人为控制，具体的执行时间也不能明确的确定，所以finalize()方法也就无法执行，因此JAVA又提供了system.gc()方法来强制启动垃圾回收器，会主动告知垃圾回收器来清理垃圾