面向对象讲义

static关键字

1.概述

以前我们定义过如下类：

public class Student {
    // 成员变量
    public String name;
    public char sex; // '男'  '女'
    public int age;
​
    // 无参数构造方法
    public Student() {
​
    }
    
    // 有参数构造方法
    public Student(String  a) {
​
    }
}

我们已经知道面向对象中，存在类和对象的概念，我们在类中定义了一些成员变量，例如name,age,sex ,结果发现这些成员变量，每个对象都存在（因为每个对象都可以访问）。

而像name ,age , sex确实是每个学生对象都应该有的属性，应该属于每个对象。

所以Java中成员（变量和方法）等是存在所属性的，Java是通过static关键字来区分的。static关键字在Java开发非常的重要，对于理解面向对象非常关键。

关于 static 关键字的使用，它可以用来修饰的成员变量和成员方法，被static修饰的成员是属于类的是放在静态区中，没有static修饰的成员变量和方法则是属于对象的。我们上面案例中的成员变量都是没有static修饰的，所以属于每个对象。

2.定义格式和使用

static是静态的意思。 static可以修饰成员变量或者修饰方法。

2.1静态变量及其访问

有static修饰成员变量，说明这个成员变量是属于类的，这个成员变量称为类变量或者静态成员变量。 直接用 类名访问即可。因为类只有一个，所以静态成员变量在内存区域中也只存在一份。所有的对象都可以共享这个变量。

如何使用呢

例如现在我们需要定义传智全部的学生类，那么这些学生类的对象的学校属性应该都是“传智”，这个时候我们可以把这个属性定义成static修饰的静态成员变量。

定义格式

修饰符 static 数据类型 变量名 = 初始值；    

举例

public class Student {
    public static String schoolName = "远宸一部"； // 属于类，只有一份。
    // .....
}

静态成员变量的访问:

格式：类名.静态变量

public static void  main(String[] args){
    System.out.println(Student.schoolName); // 远宸一部
    Student.schoolName = "周二";
    System.out.println(Student.schoolName); // 周二
}

2.2实例变量及其访问

无static修饰的成员变量属于每个对象的， 这个成员变量叫实例变量，之前我们写成员变量就是实例成员变量。

需要注意的是：实例成员变量属于每个对象，必须创建类的对象才可以访问。

格式：对象.实例成员变量

2.3静态方法及其访问

有static修饰成员方法，说明这个成员方法是属于类的，这个成员方法称为类方法或者静态方法**。 直接用 类名访问即可。因为类只有一个，所以静态方法在内存区域中也只存在一份。所有的对象都可以共享这个方法。

与静态成员变量一样，静态方法也是直接通过类名.方法名称即可访问。

举例

public class Student{
    public static void study(){
        System.out.println("今天周二");   
    }
}

静态成员变量的访问:

格式：类名.静态方法

public static void  main(String[] args){
    Student.study();
}

2.4实例方法及其访问

无static修饰的成员方法属于每个对象的，这个成员方法也叫做实例方法。

需要注意的是：实例方法是属于每个对象，必须创建类的对象才可以访问。

格式：对象.实例方法

示例：

public class Student {
    // 实例变量
    private String name ;
    // 2.方法：行为
    // 无 static修饰，实例方法。属于每个对象，必须创建对象调用
    public void run(){
        System.out.println("学生可以跑步");
    }
    // 无 static修饰，实例方法
    public  void sleep(){
        System.out.println("学生睡觉");
    }
    public static void study(){
        
    }
}
public static void main(String[] args){
    // 创建对象 
    Student stu = new Student ;
    stu.name = "徐干";
    // Student.sleep();// 报错，必须用对象访问。
    stu.sleep();
    stu.run();
}

小结

1.当 static 修饰成员变量或者成员方法时，该变量称为静态变量，该方法称为静态方法。该类的每个对象都共享同一个类的静态变量和静态方法。任何对象都可以更改该静态变量的值或者访问静态方法。但是不推荐这种方式去访问。因为静态变量或者静态方法直接通过类名访问即可，完全没有必要用对象去访问。

2.无static修饰的成员变量或者成员方法，称为实例变量，实例方法，实例变量和实例方法必须创建类的对象，然后通过对象来访问。

3.static修饰的成员属于类，会存储在静态区，是随着类的加载而加载的，且只加载一次，所以只有一份，节省内存。存储于一块固定的内存区域（静态区），所以，可以直接被类名调用。它优先于对象存在，所以，可以被所有对象共享。

4.无static修饰的成员，是属于对象，对象有多少个，他们就会出现多少份。所以必须由对象调用。

课上例题：

题目：设计一个名为 Course 的类，该类用于表示学校中的课程。每个课程都有名称、课程代码、学分。请实现以下功能：

属性：

name：课程名称（字符串类型）。 code：课程代码（字符串类型）。 credits：课程学分（整数类型）。 方法：

//Course(name, code, credits)：构造方法，用于创建一个新的课程实例。
//getCourseInfo()：返回包含课程名称、代码和学分的信息。
​
public class Course {
    private String name; //课程名称（字符串类型）
    private String code; //课程代码（字符串类型）。
    private int credits; //课程学分（整数类型）。
​
    //构造方法(有参)，用于创建一个新的课程实例
    public Course(String name, String code, int credits) {
        this.name = name;
        this.code = code;
        this.credits = credits;
    }
​
    public String getCourseInfo() {
        return "课程名称：" + name + "，课程代码：" + code + "，学分：" + credits;
    }
}
​
​
//在创建一个类测试

public static void main(String[] args) {
        //创建一个新的课程实例
        Course course = new Course("Java课程", "daima", 2);
        //返回包含课程名称、代码和学分的信息。(这里就是字符串)
        String str = course.getCourseInfo();
        System.out.println(str);  //课程名称: Java课程，课程代码：daima，学分：2

 }

封装

1.封装的步骤

1.使用 private 关键字来修饰成员变量。

2.使用public修饰getter和setter方法。

2.封装的步骤实现

private修饰成员变量

public class Student {
    private String name;
    private int age;
}

public修饰getter和setter方法

public class Student {
    private String name;
    private int age;

    public void setName(String n) {
      	name = n;
    }

    public String getName() {
      	return name;
    }

    public void setAge(int a) {
        if (a > 0 && a <200) {
            age = a;
        } else {
            System.out.println("年龄非法！");
        }
    }

    public int getAge() {
      	return age;
    }
}

继承（1）

1.概述

1.1引入

假如我们要定义如下类: 学生类,老师类和工人类，分析如下。

1. 学生类 属性:姓名,年龄 行为:吃饭,睡觉

2. 老师类 属性:姓名,年龄，薪水 行为:吃饭,睡觉，教书

3. 班主任 属性:姓名,年龄，薪水 行为:吃饭,睡觉，管理

如果我们定义了这三个类去开发一个系统，那么这三个类中就存在大量重复的信息（属性:姓名，年龄。行为：吃饭，睡觉）。这样就导致了相同代码大量重复，代码显得很臃肿和冗余，那么如何解决呢？

假如多个类中存在相同属性和行为时，我们可以将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那一个类即可。如图所示：

其中，多个类可以称为子类，单独被继承的那一个类称为父类、超类（superclass）*或者*基类。

1.2继承的含义

继承描述的是事物之间的所属关系，这种关系是：is-a 的关系。例如，兔子属于食草动物，食草动物属于动物。可见，父类更通用，子类更具体。我们通过继承，可以使多种事物之间形成一种关系体系。

继承：就是子类继承父类的属性和行为，使得子类对象可以直接具有与父类相同的属性、相同的行为。子类可以直接访问父类中的非私有的属性和行为。

1.3继承的好处

1. 提高代码的复用性（减少代码冗余，相同代码重复利用）。

2. 使类与类之间产生了关系。

2.继承的格式

通过 extends 关键字，可以声明一个子类继承另外一个父类，定义格式如下：

class 父类 {
	...
}

class 子类 extends 父类 {
	...
}

需要注意：Java是单继承的，一个类只能继承一个直接父类，跟现实世界很像，但是Java中的子类是更加强大的。

3.代码案例：

父类Human类

public class Human {
  // 合理隐藏
  private String name ;
  private int age ;
  
  // 合理暴露
  public String getName() {
      return name;
  }

  public void setName(String name) {
      this.name = name;
  }

  public int getAge() {
      return age;
  }

  public void setAge(int age) {
      this.age = age;
  }
}

子类Teacher类

public class Teacher extends Human {
    // 工资
    private double salary ;
    
       // 特有方法
    public void admin(){
        System.out.println("强调纪律问题！")；
    }
    
    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }
}

测试类

public class Test {
    public static void main(String[] args) {
        Teacher dlei = new Teacher();
        dlei.setName("坤坤");
        dlei.setAge("31");
        dlei.setSalary(1000.99);
        System.out.println(dlei.getName());
        System.out.println(dlei.getAge());
        System.out.println(dlei.getSalary());
        dlei.teach();
        
        BanZhuRen linTao = new BanZhuRen();
        linTao.setName("灵涛");
        linTao.setAge("28");
        linTao.setSalary(1000.99);
        System.out.println(linTao.getName());
        System.out.println(linTao.getAge());
        System.out.println(linTao.getSalary());
        linTao.admin();

        Student xugan = new Student();
        xugan.setName("播仔");
        xugan.setAge("31");
        //xugan.setSalary(1000.99); // xugan没有薪水属性，报错！
        System.out.println(xugan.getName());
        System.out.println(xugan.getAge());


    }
}

4.小结

1.继承实际上是子类相同的属性和行为可以定义在父类中，子类特有的属性和行为由自己定义，这样就实现了相同属性和行为的重复利用，从而提高了代码复用。

2.子类继承父类，就可以直接得到父类的成员变量和方法。

课上例题：

// 父类 Animal
class Animal {
    protected String id;
    protected String color;
    protected int age;

// 构造方法
public Animal(String id, String color, int age) {
    this.id = id;
    this.color = color;
    this.age = age;
}

// 共有行为 eat
public void eat() {
    System.out.println("The animal is eating.");
}

// 共有行为 shout
public void shout() {
    System.out.println("The animal is shouting.");
	}

}
// 子类 Cat
class Cat extends Animal {
    // 构造方法
    public Cat(String id, String color, int age) {
        super(id, color, age);
    }

// 特有行为 catchMouse
public void catchMouse() {
    System.out.println("The cat is catching mouse.");
	}

}
// 子类 Dog
class Dog extends Animal {
    // 构造方法
    public Dog(String id, String color, int age) {
        super(id, color, age);
    }

// 特有行为 watchHouse
public void watchHouse() {
    System.out.println("The dog is watching the house.");
	}

}
// 子类 Cow
class Cow extends Animal {
    // 构造方法
    public Cow(String id, String color, int age) {
        super(id, color, age);
    }

// 特有行为 plowField
public void plowField() {
    System.out.println("The cow is plowing the field.");
	}

}
public class Main {
    public static void main(String[] args) {
        // 创建 Cat 对象
        Cat cat = new Cat("001", "White", 2);
        cat.eat(); // 调用父类方法
        cat.shout(); // 调用父类方法
        cat.catchMouse(); // 调用子类特有方法

    	// 创建 Dog 对象
    	Dog dog = new Dog("002", "Black", 3);
    	dog.eat(); // 调用父类方法
    	dog.shout(); // 调用父类方法
    	dog.watchHouse(); // 调用子类特有方法

    	// 创建 Cow 对象
    	Cow cow = new Cow("003", "Brown", 4);
    	cow.eat(); // 调用父类方法
    	cow.shout(); // 调用父类方法
    	cow.plowField(); // 调用子类特有方法
	}

}

继承（2）

1.重写

1.1概念

重写（Override）: 在继承关系中，方法的名称一样，参数列表也一样 重载（Overload）：方法的名称一样，参数列表不一样 特点：创建的是子类对象，则优先使用子类方法

1.2课上笔记

1.重写:在继承关系中，父类定义一个抽象的方法，没有具体实现子类通过重写父类的方法，实现各类不同的功能。 比如:师傅会掌法，每个徒弟学的不一样， 有人会降龙十八掌，有人会玄冥神掌，有人会黯然销魂掌

2.重写的特征: 1)在继承中，于类重写父类的方法 2)方法名一样，参数列表和返回值类型一样，可以用@override标记*3.重载的特征: 1)在同一类中 2)方法名一样，参数列表不一样(参数个数、类型至少一方面不一样)

1.3注意事项

1、必须保证 父子类之间方法的名称相同，参数列表也相同（被重写的方法前面加上@Override（注解） 来检测是不是正确的覆盖重写，只会用来检测，不是必须得写） 2、子类方法的返回值必须小于等于父类方法的返回值范围 (Object类的所有类的最高公共父类) 子类方法的访问权限，必须 大于等于父类方法的访问权限 public>protected>default(什么都不写)>private

1.4重写的使用

对于已经投入使用的类，尽量不要修改，推荐定义一个新类，来重复利用其中共性内容，并且添加新改动的内容 通过继承，继承不变的内容，对需要修改的方法进行重写，添加新功能。

2.构造方法

2.1访问特点

在继承关系中，父子类构造方法的访问特点 1、子类的构造方法当中有一个默认隐含的super()调用，即默认赠送一个父类的无参数构造方法，所以先调用父类的构造方法，后执行子类的构造方法。 2、子类可以通过super来调用父类重载构造方法 3、super的父类构造调用必须是子类构造方法的第一个语句。

2.2课上笔记

1.继承中的构造方法:(核心:先有父，后有子) 创建子类对象时，先会默认调用父类的无参构造方法即使使用子类的有参构造方法创建子类对象，也是调用父类的无参构造

2.在子类的构造方法中，都隐式调用父类的无参构造可以使用super()，来显示调用父类无参构造且使用时，super()必须在子类构造方法的第一句

3.若父类有含参构造，也可以用super(参数)调用指定的含参构造

4.super在继承中指代父类对象，所以有super.属性指代父类属性super.方法()指代调用父类方法 super()指代调用父类构造。

3.super

1)父类的方法，于类重写后有不同的实现。 2)父类的引用指向不同的子类对象。

3.1super和this的用法格式

super和this完整的用法如下

this.成员变量    	--    本类的
super.成员变量    	--    父类的

this.成员方法名()  	--    本类的    
super.成员方法名()   --    父类的

使用调用构造方法格式：

super(...) -- 调用父类的构造方法，根据参数匹配确认

this(...) -- 调用本类的其他构造方法，根据参数匹配确认

3.2super(....)用法演示

代码如下：

class Person {
    private String name ="坤坤";
    private int age = 20;

    public Person() {
        System.out.println("父类无参");
    }
    
    public Person(String name , int age){
        this.name = name ;
        this.age = age ;
    }

}

class Student extends Person {
    private double score = 100;

    public Student() {
        //super(); // 调用父类无参构造方法,默认就存在，可以不写，必须再第一行
        System.out.println("子类无参");
    }
    
     public Student(String name ， int age，double score) {
        super(name ,age);// 调用父类有参构造方法Person(String name , int age)初始化name和age
        this.score = score;    
        System.out.println("子类有参");
     }
}

3.3注意：

子类的每个构造方法中均有默认的super()，调用父类的空参构造。手动调用父类构造会覆盖默认的super()。

super() 和 this() 都必须是在构造方法的第一行，所以不能同时出现。

super(..)是根据参数去确定调用父类哪个构造方法的。

3.4 小结

• 子类的每个构造方法中均有默认的super()，调用父类的空参构造。手动调用父类构造会覆盖默认的super()。

• super() 和 this() 都必须是在构造方法的第一行，所以不能同时出现。

• super(..)和this(...)是根据参数去确定调用父类哪个构造方法的。

• super(..)可以调用父类构造方法初始化继承自父类的成员变量的数据。

• this(..)可以调用本类中的其他构造方法。

多态

1.课上笔记

1)父类的方法，于类重写后有不同的实现。 2)父类的引用指向不同的子类对象。 多态的作用:父类对象作为形式参数出现在方法的参数列表，实际使用时可以传递不同的子类对象作为实参。见feed(Animal animal)精简方法，同时增强扩展性。

2.多态的形式

多态是继封装、继承之后，面向对象的第三大特性。

多态是出现在继承或者实现关系中的。

多态体现的格式：

父类类型 变量名 = new 子类/实现类构造器;
变量名.方法名();

多态的前提：有继承关系，子类对象是可以赋值给父类类型的变量。例如Animal是一个动物类型，而Cat是一个猫类型。Cat继承了Animal，Cat对象也是Animal类型，自然可以赋值给父类类型的变量。

3.多态的使用场景

如果没有多态，在下图中register方法只能传递学生对象，其他的Teacher和administrator对象是无法传递给register方法方法的，在这种情况下，只能定义三个不同的register方法分别接收学生，老师和管理员。

有了多态之后，方法的形参就可以定义为共同的父类Person。

3.1注意

• 当一个方法的形参是一个类，我们可以传递这个类所有的子类对象。

• 当一个方法的形参是一个接口，我们可以传递这个接口所有的实现类对象（后面会学）。

• 而且多态还可以根据传递的不同对象来调用不同类中的方法。

3.2代码示例：

父类：
public class Person {
    private String name;
    private int age;

    //空参构造
    //带全部参数的构造
    //get和set方法
        
    public void show(){
        System.out.println(name + ", " + age);
    }
}

//子类1：
public class Administrator extends Person {
    @Override
    public void show() {
        System.out.println("管理员的信息为：" + getName() + ", " + getAge());
    }
}

//子类2：
public class Student extends Person{

    @Override
    public void show() {
        System.out.println("学生的信息为：" + getName() + ", " + getAge());
    }
}

//子类3：
public class Teacher extends Person{

    @Override
    public void show() {
        System.out.println("老师的信息为：" + getName() + ", " + getAge());
    }
}
//测试类：
public class Test {
    public static void main(String[] args) {
        //创建三个对象，并调用register方法
        Student s = new Student();
        s.setName("张三");
        s.setAge(18);


        Teacher t = new Teacher();
        t.setName("王建国");
        t.setAge(30);
        
        Administrator admin = new Administrator();
        admin.setName("管理员");
        admin.setAge(35);
        
        register(s);
        register(t);
        register(admin);
    }

    //这个方法既能接收老师，又能接收学生，还能接收管理员
    //只能把参数写成这三个类型的父类
    public static void register(Person p){
        p.show();
    }
}

4.多态的定义和前提

多态： 是指同一行为，具有多个不同表现形式。

从上面案例可以看出，Cat和Dog都是动物，都是吃这一行为，但是出现的效果（表现形式）是不一样的。

前提【重点】

1. 有继承或者实现关系

2. 方法的重写【意义体现：不重写，无意义】

3. 父类引用指向子类对象【格式体现】

   父类类型：指子类对象继承的父类类型，或者实现的父接口类型。

5.多态的运行特点

调用成员变量时：编译看左边，运行看左边

调用成员方法时：编译看左边，运行看右边

代码示例：

Fu f = new Zi()；
//编译看左边的父类中有没有name这个属性，没有就报错
//在实际运行的时候，把父类name属性的值打印出来
System.out.println(f.name);
//编译看左边的父类中有没有show这个方法，没有就报错
//在实际运行的时候，运行的是子类中的show方法
f.show();

6. 多态的弊端

我们已经知道多态编译阶段是看左边父类类型的，如果子类有些独有的功能，此时多态的写法就无法访问子类独有功能了。

class Animal{
    public  void eat()｛
        System.out.println("动物吃东西！")
    ｝
}
class Cat extends Animal {  
    public void eat() {  
        System.out.println("吃鱼");  
    }  
   
    public void catchMouse() {  
        System.out.println("抓老鼠");  
    }  
}  
​
class Dog extends Animal {  
    public void eat() {  
        System.out.println("吃骨头");  
    }  
}
​
class Test{
    public static void main(String[] args){
        Animal a = new Cat();
        a.eat();
        a.catchMouse();//编译报错，编译看左边，Animal没有这个方法
    }
}