第二次复习内容

(一)面向对象的概念

   面向对象是一种符合人类思维习惯的编程思想。现实生活中存在各种形态不同的事物，这些事物之间存在着各种各样的联系。在程序中使用对象来映射现实中的事物，使用对象的关系来描述事物之间的联系，这种思想就是面向对象。当然，一个应用程序会包含多个对象，通过多个对象的相互配合来实现应用程序的功能，这样当应用程序功能发生变动时，只需要修改个别的对象就可以了，从而使代码更容易得到维护。

面向对象的特点主要可以概括为封装性、继承性和多态性

(1)封装性

封装是面向对象编程的核心思想，将对象的属性和行为封装起来，其载体就是类，类通常对客户隐藏其实现细节，这就是封装思想。采用封装思想保证了类的内部数据结构的完整性，使用类的用户不能轻易地操作类的数据结构，只能执行类允许公开的数据，这样子避免了外部操作和内部数据影响，提高了程序的可维护性。

（2）继承性

继承性主要描述的是类与类之间的关系，通过继承，可以在无需重新编写原有类的情况下，对原有类的功能进行扩展。继承不仅增强了代码的复用性、提高开发效率，还为程序的维护补充提供了便利。

（3） 多态性

多态性指是在程序中允许出现重名的现象，它指在一个类中定义的属性和方法被其他类继承后，它们可以具有不同的数据类型或表现出不同的行为，这使得同一个属性和方法在不同类中具有不同的语义。

（二）类的定义

(1)对象

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

public class expl1 {
//    描述人事物
//    都是人的共性内容
    int age = 10;// 定义int类型变量age1定义speak()方法
    public void speak () {
        int age=60;
            System.out.println("大家好,我今年"+ age +"岁");
    }
 
}
（2）对象的创建与使用

应用程序想完成具体的功能，仅有类是远远不够的，还需要根据类创建实例对象。在java程序中可以使用new关键字来创建对象，具体格式如下：

类名 对象名称 =new 类名（）;

例如，创建person类的实例对象代码如下：

person p=new person（）；

（3）类的封装

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

权限修饰符 

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

 【案例代码】超市购物程序设计

//商品类
//描述商品这个事物
public class Produet {
private String proName ; //商品名
public String getProName () {return proName;}
public void setProNane (String proName) {
this.proName = proName;}
}
 
//定义个超市类
//描述超市事物
//超市名字
//超市的仓库，存储商品
//售货方法
public class Market{
private String marketName;//超市名字
private Produet[] produetArr;//仓库，存储商品，里面存储若干商品
public String getmarketName(){
return marketName;
}
public void setMarketName(String marketName){
this.marketName=marketName;
}
public Produet[] getProduetArr() {
    return produetArr ;
    
}
public void setProduetArr(Produet[]produetArr) {
    this.produetArr=produetArr;
}
public Produet sell(String name) {//卖货
     for(int i=0;i<produetArr.length;i++) {//遍历循环仓库中每一个商品
         if(produetArr[i].getProName()==name) {
             return produetArr[i];
         }
     }
     return null;
}
 
}
package 第二篇复习;
//定义人类
//描述人这个事物
//人的名字 
//购物功能
 
public class people {
private String name;//人名
public String getName() {return name;}
public void setName(String name) {
    this.name=name;
}
public Produet shopping(Market market,String name) {//购物，指定去哪个超市，商品名
    return market.sell(name); //调用超市的卖货方法，指定商品名字，把卖出的货结果返回
}
}
 
public class shopping {
public static void main(String[] args) {
     //创建商品对象，给商品名字赋值
    Produet p1=new Produet();
    Produet p2=new Produet();
    Produet p3=new Produet();
    Produet p4  =new Produet();
    Produet p5=new Produet();
    p1.setProNane("电视机");
    p2.setProNane("豆浆机");
    p3.setProNane("洗衣机");
    p4.setProNane("空调机");
    p5.setProNane("吹风机");
    //创建超市对象，给超市名字赋值，给仓库赋值
    Market m=new Market();
     m.setMarketName("家乐福");
     m.setProduetArr(new Produet[]{p1,p2,p3,p4,p5});
     //创建购物者,给名字赋值
     people p=new people();
     p.setName("小强");
     //调用购物者的购物方法，指定超市和商品，得到结果
     Produet result=p.shopping(m, "豆浆机");
     if(result!=null) {
         System.out.println(p.getName()+"在"+m.getmarketName()+"买到了"+result.getProName());
     }else {
         System.out.println(p.getName()+"白跑一趟， 在"+m.getmarketName()+"什么也没买到");
 
     }
       
 
    
}
}

(三)构造方法

（1）构造方法的定义

在一个类中定义的方法如果同时满足以下三个条件，该方法称为构造方法，具
体如下:
1、方法名与类名相同
2、在方法名的前面没有返回值类型的声明
3、在方法中不能使用return语句返回一个值，但是可以单独写return语句来作为方法的结束。

（2）构造方法的重载

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

（四）this关键字

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

public void setName（String name）{
this.name=name;
}

 (五)对象的销毁

每个对象都有生命周期，当对象的生命周期结束时，

 （六）静态变量和静态方法

（1）在介绍静态变量和静态方法前，首先需要介绍static关键字，因为由static修饰的变量和方法称为静态变量和静态方法。

  被声明为static的变量和方法被称为静态成员，静态成员属于类所有，区别于个别对象，可以在本类或其他类使用类名和“.”运算符调用静态成员，语法如下：

类名.静态类成员
 （2）静态变量

在一个Java类中，可以使用static关键字来修饰成员变量，该变量被称作静态变量。静态变量被所有实例共享，可以使用“类名.变量名”的形式来访问。

注意: static关键字只能用于修饰成员变量，不能用于修饰局部变量否则编译会报错。 

（3）静态方法

要实现这样的效果，只需要在类中定义的方法前加上static关键字即可，通常称这种方法为静态方法。同静态变量一样，静态方法可以使用“类名.方法名”的方式来访问，也可以通过类的实例对象来访问。

注意:在一个静态方法中只能访问用static修饰的成员，原因在于没有被static修饰的成员需要先创建对象才能访问，而静态方法在被调用时可以不创建任何对象。

（七） 继承的概念

在Java中，类的继承是指在一个现有类的基础上去构建一个新的类构建出来的新类被称作子类，现有类被称作父类，子类会自动拥有父类所有可继承的属性和方法。在程序中，如果想声明一个类继承另一个类，需要使用extends关键字。 

父类
public class 父类类名{
 
 
}
子类需要继承父类
public class 子类类名 extends 父类类名{
 
 
 
}
（2）super 关键字

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

（3）final  关键字

   final关键字可用于修饰类、变量和方法，它有“无法改变”或者“最终的含义，因此被final修饰的类、变量和方法将具有以下特性:

1.final修饰的类不能被继承。
2.final修饰的方法不能被子类重写。

3.final修饰的变量(成员变量和局部变量)是常量，只能赋值一次

final 修饰方法，被final修饰的方法，最终方法，不能被子类重写
//
定义Animal父类 
//class Animal{
//    //使用final关键字修饰的shout()方法后，如果子类重写这个方法，编译报错
//    
//    //public  final void shout(){}
//    public void shout(){
//        
//    }
//}
创建Dog类继承父类 
//class Dog extends Animal{
//    public void shout() {
//        
//    }
//}
 
//final修饰类，最终类，不能被继承
// class Animal{    
//}
//class dog extends Animal{
//    
//    
//}
//final修饰成员变量
class Student{
    final String name="韩强";//为成为变量赋值
    //定义introduce方法，打印学生信息 
    public void introduce() {
        System.out.println("我叫"+name);
    }    
}
 
//final修饰变量，一次赋值，终身不变 
public class example07 {
public static void main(String[] args) {
    //Dog dog=new Dog();//创建Dog类的对象
    final int num=2;//第一次可以赋值；
    System.out.println(num);
    //num=4;//再次赋值，编译失败
    Student stu=new Student();
    stu.introduce();
    
}
}

(八)抽象类和接口

(1)抽象类

//抽象类的使用
// 定义抽象类Animal   
abstract class Animal{
    public abstract void shout(); //定义抽象方法
    public void sleep() {
        System.out.println("动物在睡觉");
    }
}
 
//Animal需要子类继承来使用
//定义Dog类继承Animal抽象类
  class Dog extends Animal{
    //重写父类的抽象方法，实习抽象方法
    public  void shout() {
        System.out.println("汪汪....");
    }
}
//定义测试类
public class example10 {
public static void main(String[] args) {
    Dog dog=new Dog();//创建Dog类的对象，创建的是抽象类的子类对象
    dog.shout();
    dog.sleep();
}
}

 (2)接口

如果在一个抽象类的所有方法都是抽象的，则可以将这个类用另外一种方式来定义，即接口。接口是由常量和抽象方法组成的特殊类，是对抽象类的进一步抽象。

   使用接口可以实现多重继承，一个类可以同时实现多个接口，于是可以将所有需要继承的接口放置implements关键字后使用逗号隔开，实现多个接口语法如下

 修饰符 class 类名 implement 接口1，接口2....{

}

（九）多态

（1）多态的概念

 利用多态可以使程序具有良好的扩展性，并可以对所有类对象进行通用的处理。

假如现在要编写一个绘制图形的方法draw（），如果传入正方形对象将绘制正方形，如果传入圆形对象就绘制圆形，这种场景可以使用重载来实现，定义如下：

public void draw(Square s){
//绘制正方形的方法
}
public void draw(Circular c){
//绘制圆形方法
}
  （2）多态的类型转换

对象类型的转换在java编程中经常遇到，主要包括向上转型和向下转型操作

1.向上转型

向上转型：将子类对象赋值给父类引用

(自动类型转换)

Animal  a=new Dog();

2.向下转型 

向下转型：将父类对象赋值给子类引用

（需要进行强制类型转换）

Dog a=(Dog) new Animal();

 （3）object类

  在Object类中，主要包括clone（），finalize（），equals（），toString()等方法，其中常用的两个方法为equals()和toString()方法。由于所有的类都是object类的子类，所以任何类都可以重写object类中的方法。

（1）getClass（）方法

getClass（）方法是object类定义的方法，它会返回对象执行的Class实例，然后使用该实例调用getName（）方法可以取得类的名称。语法如下：

getClass（）.getname（）；

 方法的重写

返回参数相同，方法名相同，传入参数相同，方法体不同

（2）tostring（）方法

tostring（）的功能是将一个对象返回为字符串形式，它会返回一个String实例，在实际的应用中通常重写tostring（）方法，为对象提供一个特定的输出的模式，当这个类转换为字符串或与字符串连接时，将自动调用用重写的tostring（）方法。

equals（）方法

在Java语言中，有两种比较对象的方式，分别为“==”运算符与equals（）方法，两者区别在于：“==”比较的是两个对象引用内存地址是否相等，而equals（）方法比较的是两个对象的实际内容，所以equals（）方法判断出了这两个对象实际上是同一个，而“==”运算符无法做出有效判断，如果两个对象类型的不同，那么equals（）方法就会认为两者都不同 。