Java的第八次作业

面向对象的概念及特性
1.面向对象的概念
     面向对象是一种符合人类思维习惯的编程思想。现实生活中存在各种形态不同的事物，这些事物之间存在着各种各样的联系。在程序中使用对象来映射现实中的事物，使用对象的关系来描述事物之间的联系，这种思想就是面向对象。
     提到面向对象，自然会想到面向过程，面向过程就是分析出解决问题所需要的步骤，然后用函数把这些步骤一一实现，使用的时候依次调用就可以了。面向对象则是把构成问题的事务按照一定规则划分为多个独立的对象然后通过调用对象的方法来解决问题。当然，一个应用程序会包含多个对象，通过多个对象的相互配合来实现应用程序的功能，这样当应用程序功能发生变动时，只需要修改个别的对象就可以了，从而使代码更容易得到维护。

2.面向对象的特点
2.1封装性
    封装是面向对象的核心思想，将对象的属性和行为封装起来，不需要让外界知道具体实现细节，这就是封装思想。例如，用户使用电脑，只需要使用手指敲键盘就可以了，无需知道电脑内部是如何工作的，即使用户可能碰巧知道电脑的工作原理，但在使用时，并不完全依赖电脑工作原理这些细节。
2.2继承性
    继承性主要描述的是类与类之间的关系，通过继承，可以在无需重新编写原有类的情况下，对原有类的功能进行扩展。例如，有一个汽车的类，该类中描述了汽车的普通特性和功能，而轿车的类中不仅应该包含汽车的特性和功能，还应该增加轿车特有的功能，这时，可以让轿车类继承汽车类在轿车类中单独添加轿车特性的方法就可以了。继承不仅增强了代码的复用性、提高开发效率，还为程序的维护补充提供了便利。

2.3多态性
    多态性指的是在程序中允许出现重名现象，它指在一个类中定义的属性和方法被其它类继承后，它们可以具有不同的数据类型或表现出不同的行为，这使得同一个属性和方法在不同的类中具有不同的语义。例如，当听到“Cut”这个单词时，理发师的行为是剪发，演员的行为表现是停止表演，不同的对象，所表现的行为是不一样的。
 

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

    在Java中，定义在类中的变量被称为成员变量，定义在方法中的变量被称为局部变量。如果在某一个方法中定义的局部变量与成员变量同名，这种情况是允许的，此时方法中通过变量名访问到的是局部变量，而并非成员变量。

class Person{
               int age = 10;//类中定义的变量被称作成员变量
               void speak(){
                           int age=60;//方法内部定义的变量被称作局部变量
                           System.out.print("大家好，我今年“+age+"岁|")；
}
}
P47.对象的创建

 应用程序想要完成具体的功能，仅有类是远远不够的，还需要根据类创建实例对象。

在Java中可以用new关键字来创建对象，具体格式如下：

类名 对象名称 =new 类名()；
类的设计
    在Java中，对象是通过类创建出来的。因此，在程序设计时，最重要的就是类
的设计。接下来就通过一个具体的案例来学习如何设计一个类。

    假设要在程序中描述一个学校所有学生的信息，可以先设计一个学生类(Student)，在这个类中定义两个属性name、age分别表示学生的姓名和年龄定义一个方法introduce()表示学生做自我介绍。

public class Student {
String name;    //定义一个姓名属性·    
int age;    //定义一个年龄属性    
public void introduce(){*
//方法中打印属性name和age的值
System.out.printin("大家好，我我叫"+name +",我今年"+ age +"岁!");

}
}
类的封装
    在设计一个类时，应该对成员变量的访问作出一些限定，不允许外界随意访问这就需要实现类的封装。
    所谓类的封装是指在定义一个类时，将类中的属性私有化，即使用private关键字来修饰，私有属性只能在它所在类中被访问，如果外界想要访问私有属性，需要提供一些使用public修饰的公有方法，其中包括用于获取属性值的getXxx方法和设置属性值的setXxx方法。

构造方法的定义
在一个类中定义的方法如果同时满足以下三个条件，该方法称为构造方法，具体如下:

}
}
类的封装
    在设计一个类时，应该对成员变量的访问作出一些限定，不允许外界随意访问这就需要实现类的封装。
    所谓类的封装是指在定义一个类时，将类中的属性私有化，即使用private关键字来修饰，私有属性只能在它所在类中被访问，如果外界想要访问私有属性，需要提供一些使用public修饰的公有方法，其中包括用于获取属性值的getXxx方法和设置属性值的setXxx方法。

构造方法的定义
在一个类中定义的方法如果同时满足以下三个条件，该方法称为构造方法，具体如下:

[修饰符] 类名(形参列表){
 
    //n条语句
 
}

构造方法的重载

与普通方法一样，构造方法也可以重载，在一个类中可以定义多个构造方法，只要每个构造方法的参数类型或参数个数不同即可。在创建对象时，可以通过调用不同的构造方法来为不同的属性进行赋值。

代码：

public class User {
    int id;
    String name;
    String pwd; //密码
    public User() {
        
    }
    public User(int id,String name) {
        this.id = id;
        this.name = name;
    }
    public User(int id,String name,String pwd) {
        this.id = id;
        this.name = name;
        this.pwd = pwd;
    }
    public static void main(String[] args) {
        User u1 = new User();
        User u2 = new User(101,"fei");
        User u3 = new User(102,"fei","123456");
    }
    
}

this关键字的使用
例如都声明为age。但是这样做又会导致成员变量和局部变量的名称冲突，在方法中将无法访问成员变量age。为了解决这个问题，Java中提供了一个关键字 this来指代当前对象，用于在方法中访问对象的其它成员。this 关键字是 Java 常用的关键字，可用于任何实例方法内指向当前对象，也可指向对其调用当前方法的对象，或者在需要当前类型对象引用时使用。

语法：

public class Teacher {
    private String name;    // 教师名称
    private double salary;    // 工资
    private int age;    // 年龄
}
// 创建构造方法，为上面的3个属性赋初始值
public Teacher(String name,double salary,int age) {
    this.name = name;    // 设置教师名称
    this.salary = salary;    // 设置教师工资
    this.age = age;    // 设置教师年龄
}

垃圾回收
    在Java中，当一个对象成为垃圾后仍会占用内存空间，时间一长，就会导致内存空间的不足。针对这种情况，Java中引入了垃圾回收机制。有了这种机制，程序员不需要过多关心垃圾对象回收的问题，Java虚拟机会自动回收垃圾对象所占用的内存空间。
    一个对象在成为垃圾后会暂时地保留在内存中，当这样的垃圾堆积到一定程度时，
Java虚拟机就会启动垃圾回收器将这些垃圾对象从内存中释放，从而使程序获得更多可用的内存空间。除了等待Java虚拟机进行自动垃圾回收外，还可以通过调用Svstem.gc()方法来通知Java虚拟机立即进行垃圾回收。当一个对象在内存中被释放时，它的finalize()方法会被自动调用，因此可以在类中通过定义finalize()方法来观察对象何时被释放。

static关键字
    在定义一个类时，只是在描述某类事物的特征和行为，并没有产生具体的数据。只有通过new关键字创建该类的实例对象后，系统才会为每个对象分配空间，存储各自的数据。有时候，开发人员会希望某些特定的数据在内存中只有一份而且能够被一个类的所有实例对象所共享。例如某个学校所有学生共享同一个学校名称，此时完全不必在每个学生对象所占用的内存空间中都定义一个变量来表示学校名称，而可以在对象以外的空间定义一个表示学校名称的变量，让所有对象来共享。

在一个Java类中，可以使用static关键字来修饰成员变量，该变量被称作静态变量。静态变量被所有实例共享，可以使用“类名.变量名”的形式来访问。接下来通过一个案例来描述，static关键字只能用于修饰成员变量，不能用于修饰局部变量。否则编译会报错。

package cnitcastchapter03.example12;/*
*静态的变量
class Student{
static String schoolName;//定义静态变量3choo1Name
public class Example12{
public static void main(String[] args) throws Exception{
Student stu1=new Student)://创建学生对象 Student stu2=new Student();//静态成员的调用方式，类名，对象。
Student.schooIName="传智播客";//为静态变量赋值
System.out.println("我的学校是:"+stu1.schooIName);// 打印第一个学生对象的学校名 System.out.println("我的学校是:"+ stu2.schooIName);// 打印第二个学生对象的学校名
}
}静态方法
    在实际开发时，开发人员有时会希望在不创建对象的情况下就可以调用某个方法，换句话说也就是使该方法不必和对象绑在一起。要实现这样的效果，只需要在类中定义的方法前加上static关键字即可，通常称这种方法为静态方法。同静态变量一样，静态方法可以使用“类名.方法名”的方式来访问，也可以通过类的实例对象来访问。
    注意:在一个静态方法中只能访问用static修饰的成员，原因在于没有被static修饰的成员需要先创建对象才能访问，而静态方法在被调用时可以不创建任何对象。
1 package cnitcast.chapter03example13;2e/*
3静态方法的使用4 */
5 class Person{
6
7e    publie static void sayhello(){ // 定义静态方法    
8    System.out.println("hello");    
9
10)
11 public class Example13(
12日    public static void main(String[l args) throws Exception{    
13    //1类名方法的方式调用静态方法    
14    Person.sayHello();    
15    //2实例化对象的方式调用静态方法    
16    Person p=new Person();    
17    p.sayHello();    
18    }    
19}

静态代码块

在Java类中，使用一对大括号包围起来的若干行代码被称为一个代码块，用static关键字修饰的代码块称为静态代码块。当类被加载时，静态代码块会执行由于类只加载一次，因此静态代码块只执行一次。在程序中，通常会使用静态代码块来对类的成员变量进行初始化。

package cnitcast.chapter03.example14;/*
*静态代码块*/
class Person{
/静态代码块 staticl
System.out.println("Person类中的静态代码块执行了");
 
public class Example14(
//静态代码块 staticl
System.out.println("测试类的静态代码块被执行了");
 
public static void main(Stringl args)throws Exception{
//下面代码创建两个Person对象 
Person p1=new Person(); Person p2=new Person();

成员内部类
    Java中，允许在一个类的内部定义类，这样的类称作内部类，这个内部类所在的类称作外部类。根据内部类的位置、修饰符和定义的方式可分为:成员内部类、静态内部类、方法内部类。本小节将针对成员内部类进行讲解。在一个类中除了可以定义成员变量、成员方法，还可以定义类，这样的类被称作成员内部类。在成员内部类中，可以访问外部类的所有成员。如果想通过外部类去访问内部类，则需要通过外部类对象去创建内部类对象，创建内部类对象的具体语法格式如下:
 

外部类名内部类名变量名=new外部类名()new内部类名0);
继承的概念
类之间的这种关系被称为关联.关联主要描述两个人类之间的一般二次关系,继承是关联的一种.(继承性主要利用特定对象之间的共有属性)

继承关系可以用树型关系来表示,父类与子类存在一种层次关系.一个类处于继承体系中,它既可以是其他类的父类,为其他类提供属性和行为,也可以是其他类的子类,继承父类的属性和方法,如三角形既是图形类的子类也是等边三角形的父类。

 在Java语言中一个类要继承另一个类要使用关键字extends格式如下：

class 父类 {
}
 
class 子类 extends 父类 {
}
super关键字
当子类重写父类的方法后，子类对象将无法访问父类被重写的方法，为了解决这个问题，在Java中专门提供了一个super关键字用于访问父类的成员。例如访问父类的成员变量、成员方法和构造方法:接下来分两种情况来学习一下super关键字的具体用法。
1.使用super关键字访问父类的成员变量和成员方法。具体格式如下:

super.成员变量
super.成员方法（[参数1，参数2...]）

2.使用super关键字访问父类的构造方法。具体格式如下:
 

super([参数1，参数2...]）;
final关键字
 final关键字可用于修饰类、变量和方法，它有“无法改变”或者“最终的含义，因此被final修饰的类、变量和方法将具有以下特性:
·final修饰的类不能被继承。
·final修饰的方法不能被子类重写。
·final修饰的变量(成员变量和局部变量)是常量，只能赋值一次。

语法：

final class 类名 {//类体}
修饰符(public/private/default/protected) final 返回值类型 方法名(){//方法体}
抽象类

多态的概述
    在设计一个方法时，通常希望该方法具备一定的通用性。例如要实现一个动物叫的方法，由于每种动物的叫声是不同的，因此可以在方法中接收一个动物类型的参数，当传入猫类对象时就发出猫类的叫声，传入犬类对象时就发出犬类的叫声。在同一个方法中，这种由于参数类型不同而导致执行效果各异的现象就是多态。继承是多态得以实现的基础。
    在Java中为了实现多态，允许使用一个父类类型的变量来引用一个子类类型的对象，根据被引用子类对象特征的不同，得到不同的运行结果。

多态就是同一个接口，使用不同的实例而执行不同操作，如图所示：

多态性是对象多种表现形式的体现。

多态存在的三个必要条件

继承

重写

父类引用指向子类对象：Parent p = new Child();

对象的类型转换
向上转型可以被可以被理解为将子类类型的对象转换为父类类型的对象，即把子类类型的对象直接赋值给父类类型的对象，进而实现按照父类描述子类的效果。

通俗地讲即是将子类对象转为父类对象。

Father f1 = new Son();//向上转型
向下转型与向上转型相反，即是把父类对象转为子类对象，但是，运用向下转型，如果把一个较抽象的类的对象转换为一个更具体的类的对象，这样的转型通常会出现错误。

子类类型 子类对象 =（子类类型）父类对象;
Girl g2=new Girl();
MMGirl mmg1=(MMGirl)g2; //不安全的向下转型,编译无错但会运行会出错
Object类
在JDK中提供了一个Object类，它是类层次结构的根类，每个类都直接或间接继
承自该类，所有对象(包括数组)都实现了这个类的方法。Object类中的常用方法如下表所示。

 匿名内部类
    在编写Java程序时，在类里面定义的类称之为内部类(InnerClass)，内部类是外部类的一个成员。Java内部类可以分为:成员内部类、方法内部类和匿名内部类等。
    在前面多态的讲解中，如果方法的参数被定义为一个接口类型，那么就需要定义一个类来实现接口，并根据该类进行对象实例化。除此之外，还可以使用匿名内部类来实现接口。所谓匿名内部类就是没有名字的内部类，表面上看起来它似乎有名字，实际那不是它的名字。当程序中使用匿名内部类时，在定义匿名内部类的地方往往直接创建该类的一个对象。

代码：

//定义测试类
public class Example18{
public static void main(String[] args){    
//定义一个内部类cat实现Animal接口    
class CatimplementsAnimal{    
//实现shout()方法    
public void shout()(    
System.out.println("喵喵...");    
5
16    }    
animalShout(newCat());//调用animalshout()方法并传入Cat对象    
//定义静态方法animalShout()    
public static void animalShout(Animal an){    
an.shout();//调用传入对象an的shout()方法