面向对象

一、类： class 

new ： 生成对象时，分配内存空间

二、构造方法：

1、特征

（1） 没有类型

（2） 方法名与类名完全一致

2、目的

就是对刚刚分配的空间赋值，即对新建的对象赋值。

3、使用场合

  只能在new的后面

三、类和对象的关系

（1）类是对象的模板，抽象，整体

（2）对象是类的实例，具体，个体

变量的介绍：有两种

1、在类中定义的变量，成员变量。

（1）没有static修饰的，实例变量

（2）有static修饰的，类变量     整个类 只有一个

2、在方法中定义的变量，局部变量

 （1）方法定义时形式参数

（2）方法体内定义的变量

方法的介绍

（1）有static修饰的，类方法

（2）没有static修饰的 ，实例方法

方法体内的调用情况

1、类方法可以直接调用

（1）类变量            （2）类方法

2、实例变量可以直接调用

（1）类变量            （2）类方法                   （3）实例变量                        （4）实例方法

对象和类的调用情况

1、对象的调用

（1）类变量           （2）类方法                    （3）实例变量                           （4）实例方法

2、类的调用

（1）类变量                （2）类方法

  

四、方法的重载

  方法名相同，类型相同，但是参数不同：个数、类型

  public Student(){
   }
public Student(String stuID,String stuName){
this.stuID=stuID;
this.stuName=stuName;
}

五、封装

将类中的实例变量私有化。

private：实例变量仅在本类中有效，在其他类中无法访问。

要对外提供接口：getter和setter

目的：

（1）保护敏感数据，不被外界随意的访问和修改

（2）对外提供接口，简化操作

getter 

特征：

public String getName(){
     return this.name;
}

1、以get开头

2、没有参数

3、有返回值，即方法有类型

setter

特征：

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

1、以set开头

2、有参数

3、没有返回值，即方法的类型为void

this

1、this.实例变量

2、this.实例方法

3、this():调用本类中其他的构造方法

public class Student1 {
   String id;
   String name;
   public Student1() {
	   this("S001","刘备");
   }
   public Student1(String id,String name) {
	   this.id=id;
	   this.name=name;
   }
   public static void main(String[] args) {
	   Student1 s=new Student1();
	   System.out.println(s.id+","+s.name);
   }
}

六、继承

1.目的：代码的重用

2.extends 实现继承

super

1、super.实例变量

2、super.实例方法

3、super(): 调用父类的构造方法

继承时子类的构造方法

1、子类的构造方法的第一句，一定是super().

public class Student1 {
   String id;
   String name;
   public Student1() {
	   this("S001","刘备");
   }
   public Student1(String id,String name) {
	   this.id=id;
	   this.name=name;
   }

}

public class Monitor extends Student1{
	String duty;
	public Monitor() {
		super();
	}
	public Monitor(String id,String name,String duty)
	{
		super(id,name);
		this.duty=duty;
	}
}

方法的重写

继承存在时，父类和子类的方法名相同，类型相同，参数相同，唯一的不同是方法体不同，即功能不同。

多态

理解：同一个动作，不同的对象会做出不同的反应。

当方法的重写存在时，并且对象的声明用父类，构造用子类，这是对象.方法（）。

此时方法的调用：编译时，以父类为准，运行时以子类为准。

当父类和子类存在相同的实例变量时，并且对象的声明用父类，构造用子类，这时对象.实例变量。表示调用父类的实例变量。

七、抽象

1、abstract：修饰类，方法。

修饰方法时，方法没有方法体，只有声明。

2、抽象方法和抽象类的关系

（1）、如果一个类中有一个抽象方法，则该类必须是抽象的。

（2）、如果一个类中没有抽象方法，只有正常方法，则该类可以是抽象的。

（3）、抽象类是不能直接创建对象的

（4）、抽象类一般都有子类，用子类来创建对象。

八、接口

 定义： interface 接口名{
    定义常量
  定义public abstract 类型 方法名();
}

实现：implements

class 类名 extends 父类名 implements 接口1，接口2，接口3....

常用的关键字：

1. class                 2.new                 3.this                   4.static                       5.private

6.extends             7.super               8.abstract           9.interface                  10.implements

11.final                12.public             13.protected