Java第六章总结

面向对象概述
1.掌握类的封装特性，构造方法的定义 重载已经this和static关键字的使用

2.熟悉类与对象的创建和使用

3.了解面对对象的三大特征

  面对对象的特点主要可以概括为封装性，继承性，多态性 接下来是这三种特性的一个简单介绍。

1.封装性

 2.继承性

3.多态性 

类与对象

1.类

面对对象的编程思想，力图让程序中对事物的描述与该事物在视线中形态保持一致，

为了做到这点，面向对象的思想中提出了连个概念，即类和对象。其中，类是对某一类事物的抽象描述，而对象用于表示现实中该类事物的个体。

2.类的定义

在面向对象的思想中最核心的就是对象，为了在程序中创建对象，首先需要定义一个类。雷士对象的抽象，它用于描述一组对象的共同特征行为。类中可以定义成员变量和成员方法，其中成员变量用于描述对象的特征，也被称作属性，成员方法用于米哦啊书对象的行为，可简称为方法。

对象是事物存在的实体 如人 书桌 计算机 大楼大厦等。

所有对象都分静态部分和动态部分

能去掉的是动态

不能去掉的是静态

类就是对象的设计图 类是同一类食物的同城 如果将现实世界中的一个事物抽象成对象 类就是这类对象的统称

静态属性----成员变量

动态属性----成员方法

多态

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

1.什么是封装？

把静态和动态的属性放到同一个类中

2.什么是多态？

多态是同一个行为具有不同的表现形式或形态的能力

同一方法可以根据发送对象的不同而采用不同的行为方式

3.什么是继承？

当子类继承父类后，就可以直接使用父类公共的属性和方法了

所有构造方法都是 public类型的

成员变量

代码：

package 面对对象;
 
public class 例题2 {//类
private String name;//String类型的成员变量
public String getName() {//name的Getter的方法
        return name;//在有返回值的方法中 返回方法指定类型的值 同时结束方法执行
}
public void setName(String name) {//name的Setter的方法
    this.name = name;//将 参数name的值赋值给 本对象的成员变量name。
}
}

先创建一个类 然后定义一个String类型的成员变量

在使用Getter的方法

在有返回值的方法中，返回方法指定类型的值 同时结束方法执行

再name的Setter方法

将参数值赋予类中的成员变量

成员方法

权限修饰符 返回值类型 方法名（参数类型 参数名）{
...
return 返回值
}

成员方法的返回值可以是计算结果，也可以是其他想要的数值和对象，返回值类型要与方法返回的值一致。

权限修饰符

例如，在项目中的com.mr包下创建AnyClass类，该类使用默认的访问权限 。

package com.mr;
class AnyClass{
public void doString(){
....//方法体
}
}

在上述代码中 由于类的修饰符为默认修饰符，即只有一个包内的其他类和子类可以对该类进行访问，而AnyClass类中的doString()方法却又被设置为public访问权限，即使这样doString（）方法的访问权限依然与AnyClass类的访问权限相同。

局部变量

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

代码：

package 面对对象;
 
public class 例题4 {
    public static int[]exchange(int[]arr){
    int tmp =arr[0];//把arr[0]赋值给局部变量tmp 把17赋值给tmp现在tmp是17
    arr[0]=arr[1];//把arr[1]复制给arr[0] 把29赋值给arr[0] 现在arr[0]是29
    arr[1]=tmp;//把tmp复制给arr[1] 现在tmp是17 就等于把17赋值给了arr[1] 所做出的交换
    return arr;
    }
public static void main(String[]args) { //权限修饰符 输出值 空 主方法 返回值//主方法
    int arr[]= {17,29};
    System.out.println("第一个值="+arr[0]+"第二个值="+arr[1]);//输出
    arr =exchange(arr);
    System.out.println("第一个值+"+arr[0]+"第二个值="+arr[1]);//输出
}
}

运行结果：

局部变量的有效范围

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

下面代码描述了变量的作用范围。

package 面对对象;
 
public class 例题5 {
    public void doString(String name) {
        int id = 0;
        for (int i=0;i<10;i++) {
            System.out.println(name+String.valueOf(i));
        }
    }
 
}

 在相互不嵌套的作用域中可以同时声明两个名称和类型相同的局部变量如下面代码所示：

public void doString(String name) {
        int id = 0;
        for (int i=0;i<10;i++) {
            System.out.println(name+String.valueOf(i));
        }
    for(int i=0;i<3;i++) {
        System.out.println(i);
    }
    }

但是在相互嵌套的区域中不可以这样子声明，如果将局部变量id在方法体中for循环再次定义编译器将会报错如下代码所示：

public void doString(String name) {
        int id = 0;
        for (int i=0;i<10;i++) {
            System.out.println(name+String.valueOf(i));
        }
    for(int i=0;i<3;i++) {
        System.out.println(i);
        int id=7;
    }
    }

this关键字

this关键字用于表示本类当前的对象，当前对象不是某个new出来的实体对象而是当前正在编译的类。this关键字只能在本类中使用。例如 图书类setName()方法代码如下：

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

this除了可以调用成员变量或成员方法，还可以作为方法的返回值，例如 返回图书类的苯类的对象可以写成下面这种形式：

public Book getBook(){
        return this;//返回BooK类的本类对象
    }

再getBook()方法中范围值Book类，所以方法体中使用了return this这种形式返回Book类对象

类的构造方法

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

构造方法的特点如下：

构造方法没有返回值；

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

publicBook（）{
...//构造方法
}

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){
        EggCake cake1=new EggCake();
        System.out.println("顾客不要求加蛋的数量，饼里会有"+cake1.eggCount+"个蛋。 ");//输出
                EggCake cake2=new EggCake(2);
        System.out.println("顾客要求加2个蛋，饼里会有"+cake2.eggCount+"个蛋。");//输出
        }
}

运行结果：

静态变量和静态方法

在介绍静态便连个静态方法之前 要介绍static关键字 应为有static修饰的变量和方法被称为静态变量和静态方法。

代码：

package 面对对象;
 
public class StaticDemo {
    //静态的成员变量
    static double P1=3.1415;//static就是静态变量
    static final double P2=3.1415;//有static final就静态常量
    //静态常量
    public static void method() {static就是静态方法
        //静态的成员方法
        System.out.print("这是静态方法");
    }
    
    public static void main (String[]args) {//调用静态变量
        System.out.println(StaticDemo.P2);//输出要选择你要输出的
        StaticDemo.method();//调用成员方法
    }
}

运行结果：

      

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

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

代码：

package 面对对象;
 
public class Cust {//吃货类
static int count =0;//共享的属性：人数
String name;//名称属性
public Cust(String name) {
    this.name =name;//记录名称
    count++;//人数递增
}
 
public static void main(String[]args) {//主方法 
    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+"名吃货i,我叫"+c3.name);//输出
}
}

运行结果：

类的主方法

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

publie static void main(String[]args){
....
}

 

读取主方法的参数值

创建MainDemo类在著方法中编写以下代码

package 面对对象;

public class MainDemo {

public static void main(String[]args) {//定义主方法

for(int i = 0;i<args.length;i++) {//根据参数个数做循环操作

System.out.println(args[i]);//循环打印参数内容

}

}

}

运行代码前 现在Eclipsez中设置运行参数

运行结果：

 

对象

java时一门面向对象的程序设计语言，对象是由类实例化而来的 所有问题都通过对象来处理对象可以通过操作剋的属性和方法来解决相应问题，所以了解对象的产生，操作和小王是十分必要的 本章节来讲解java语言中的应用

对象的创建

在6.1节中曾讲过对象 对象可以认为是在一类事物中抽象出某一个特例可以通过这个特例来处理这类事物的出现的问题在java语言中 通过new操作符来创建对象。前文在讲解构造方法时介绍过 每实例化一个对象就会自动调用一次构造方法，实质上这个过程就是创建对象的过程中准确的说可以在java语言中使用new操作符调用构造对象 语法如下：

Test etst =new Test();
Test etst =new Test("a");

 例题：创建人类并创建对象

package 面对对象;
 
public class People {
    private String name;//定义一个字符串类型 赋值为名字
    private int age;//定义一个整型变量  年纪
    private String sex;//定义一个字符串类型  赋值为性别
    public People(String name,int age,String sex) {//成定义一个成员变量   人（名字 年纪 性别）
        this.name =name;//抛弃就近原则选择成员变量中的 
        this.age =age;//抛弃就近原则选择成员变量中的
        this.sex=sex;//抛弃就近原则选择成员变量中的
    }
    public static void main(String[]args) {
        People p1= new People("tom",23,"男");//人p1赋值名字和年龄和性别
        People p2= new People("lily",19,"女");//人p1赋值名字和年龄和性别
    }
}
 

代码图：

访问对象的属性和行为

代码：

package 面对对象;
 
public class Dog {
String name;//定义字符串类型的 name 名字
String Color;//定义字符串类型的 name 名字
String vioce;//定义字符串类型的 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();
    }
}

 代码：

 运行结果：

 

对象的引用

在java语言中，尽管一切都可以看作对象 但真正的操作标识符实质上是一个引用那么引用在java中是如何体现按的呢语法如下：

类名  对象的引用变量

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

People tom；

通常一个引用不一定需要有一个对象的相关联应用于对象相关联的语法如下：

People tom=new People（）；

对象的销毁

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

对象引用超过起作用范围 这个对象将被视为垃圾 如下所示:

{
Examblee =new Example();
}

对象超过作用范围将消亡

将对象赋值为null 如下所示：

{Examble e=new Examble
e =null;
}

虽然java的垃圾回收站机制已经很完善 但垃圾回收器只能回收那些由new操作符创建的对象。某些对象不能通过new操作符获储存空间的 这种对象无法被垃圾回收站机制所识别。 在java中提供了一个finalize（）方法这个方法是Object类的方法他被声明为protected，用户可以在自己的类中定义这个方法，如果用户在类中定义finalize()方法在垃圾回收时首先调用该方法 ，在下依次垃圾回收动作发生时 才真正回收被对象占用的内存。