使用Java实现面向对象编程

•                        *使用·Java实现面向对象编程
  

/**

面向对象
一、类和对象

1:静态的描述声明为类的成员变量,成员变量描述对象有什么
2:动态的描述声明为类的成员方法,成员方法描述对象可以做什么
3:成员方法可以直接使用成员变量
4.每个对象都有一套属于自己的成员变量

• static 的作用
• 作用1
• 用来修饰成员变量
• 则该成员变量就变成了类变量 或者叫静态成员变量
• 静态成员变量被这个类创建出来的所有的对象所共享
• 静态成员变量可以通过类名直接调用
• 非静态成员变量只能通过对象来调用
• 当一个类创建出来的每一个对象的某一个成员变量的值都相等
• 则这个时候可以将这个类中的该成员变量声明为静态成员变量
• 作用2
• 用来修饰成员方法
• 则该成员方法就变成了类方法，或者叫静态方法
• 静态方法可以直接用类名来调用
• 可以方便我们简单快速的无需创建对象就能调用方法
• 作用3
• 可以用来修饰代码块
• 则该代码块就是静态代码块
• 当一个类被成功加载到内存的时候 系统会自动执行静态代码块
• 静态代码块可以用来初始化类的静态成员变量

/
public class Student {
String name;
int age;
static String city;
static String sbj;
public static void study() {
System.out.println(“学生在学习java”);
}
/*

• 普通代码块
• 创建对象的时候 系统自动调用
• 每创建一个对象就执行以下普通代码块
• 普通代码块中可以使用静态或非静态的成员变量
  /
  {
  System.out.println(“普通代码快”);
  name = “wangcai”;
  city = “广州”;
  }
  /*
• 静态代码块
• 当当前的类被成功加载到内存中的时候 系统会自动执行静态代码块
• 只会执行一次
• 静态代码块可以使用静态成员变量
• 静态代码块不可以使用非静态成员变量
  */
  static{
  city = “广州”;
  sbj = “java”;
  System.out.println(“静态代码块”);
  }
  }

public class StaticDemo {
public static void main(String[] args) {
Student stu01 = new Student();
Student stu02 = new Student();
Student stu03 = new Student();
Student stu04 = new Student();
}
}

/**

• this 关键字

• 代表当前对象的引用

• 通过那个对象执行到this 这一行代码了，那个对象就是当前对象

• 1.调用成员变量

• 当成员变量和局部变量重名的时候使用this 来调用成员变量

• 2.调用成员方法

• 3.调用构造方法

• 在构造方法里面可以使用this来调用当前类中的其他构造方法
  */
  public class Dog {
  String name;
  int age;
  String brand;
  public Dog() {
  }
  public Dog(String name) {
  //当局部变量和成员变量重名的时候 使用this来调用成员变量
  this.name = name;
  }
  public Dog(String name,int age) {
  //这个操作是在调用 Dog(String name) 这个构造方法
  this(name);
  this.age = age;
  }
  public Dog(String name,int age,String brand) {
  this(name, age);
  this.brand = brand;
  }
  public void test() {
  System.out.println(“test01”);
  //this 一定是一个Dog的对象，既然是一个dog的对象 所以就可以用来调用Dog类中的所有方法
  this.test02();
  }
  public void test02() {
  System.out.println(“test02”);
  }
  }

public class Test {
public static void main(String[] args) {
Dog wangcai = new Dog();
System.out.println(wangcai);
wangcai.test();
Dog dahuang = new Dog();
System.out.println(dahuang);
dahuang.test();
}
}

super关键字作用
1：主要存在于子类方法中，用于指向子类对象中的父类对象。
2：访问父类的属性
3：访问父类的函数
4：访问父类的构造函数
二.super注意的地方
this和super很像，this指向的是当前对象的调用，super指向的是当前调用对象的父类。类加载完毕，创建对象，父类的构造方法会被调用（默认自动无参），然后执行子类相应构造创建了一个子类对象，该子类对象还包含了一个父类对象。该父类对象在子类对象内部。this super只能在有对象的前提下使用，不能在静态上下文使用。
三.super关键字的使用
1.子类的构造函数默认第一行会默认调用父类无参的构造函数，隐式语句super();

2.子类显式调用父类构造函数
在子类构造函数第一行通过super关键字调用父类任何构造函数。如果显式调用父类构造函数，编译器自动添加的调用父类无参数的构造就消失。构造函数间的调用只能放在第一行，只能调用一次。super()和this()不能同时存在构造函数第一行。
4.在构造方法中第一行永远都是用super来调用父类的方法
3.如果开发者自定义了一个类，没有显示的进行类的继承，那么该类中成员函数是否可以使用super关健健字？可以使用，继承了Object类，Object类是所有类的父类。

1. 面向过程和面向对象的区别：
   面向过程：我们首先思考“怎么按步骤实现?”并将步骤对应成方法，一步一步，最终完成。
   面向对象：把构成问题事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为 了描叙某个事物在整个解决问题的步骤中的行为。

2、 类和对象的关系：
(1).对象是具体的事物;类是对对象的抽象;
(2).类可以看成一类对象的模板，对象可以看成该类的一个具体实例。
(3).类是用于描述同一类型的对象的一个抽象概念，类中定义了这一类对象所应具 有的共同的属性、方法。

3、构造方法的作用和特征：
作用：用于对象的初始化
特征：
(1). 通过new关键字调用!!
(2). 构造器虽然有返回值，但是不能定义返回值类型(返回值的类型肯定是本类)，不能在构造器里使用return返回某个值。
(3). 如果我们没有定义构造器，则编译器会自动定义一个无参的构造函数。如果已定义则编译器不会自动添加!
(4). 构造器的方法名必须和类名一致!

4、this关键字的作用和用法：
作用：创建好的对象的地址
用法：
(1). 在程序中产生二义性之处，应使用this来指明当前对象;普通方法中，this总是指向调用该方法的对象。构造方法中，this总是指向正要初始化的对象。
(2). 使用this关键字调用重载的构造方法，避免相同的初始化代码。但只能在构造方法中用，并且必须位于构造方法的第一句。
(3). this不能用于static方法中。

5、简述static关键字的作用：
提示：从static可以修饰变量，方法，代码块，三个方面来回答。
(1). 为该类的公用变量，属于类，被该类的所有实例共享，在类被载入时被显式初始化。
(2). 对于该类的所有对象来说，static成员变量只有一份。被该类的所有对象共享!!
(3). 一般用“类名.类属性/方法”来调用。(也可以通过对象引用或类名(不需要实例化)访问静态成员。)
(4). 在static方法中不可直接访问非static的成员。
/**

• 构造方法 （是一种特殊的方法）
  定义： 一个在创建对象时被自动调用的特殊方法。
• 是创建对象的时候自动调用的方法
• 可以用来初始化对象的成员变量
• 可以帮助我们 简单快速的创建对象
• 构造方法的特征
• 1.构造方法必须跟类名重名
• 2.构造方法不用声明返回值
• 3.构造方法也可以重载
• 4.如果什么构造方法都不写，则系统会自动生成一个无参的构造方法
• 如果我们写了带参数的构造方法， 系统就不会再自动生成无参的构造方法了
  /
  public class Dog {
  String name;
  int age;
  /*
• 不带参数的构造方法
• 可以给成员变量一个初始值
  /
  public Dog(){
  name = “狗子”;
  age = 1;
  }
  /*
• 创建对象的时候 顺便指定一个名字
  /
  public Dog(String n) {
  name = n;
  }
  /*
• 创建对象的同时 给dog的对象指定一个名字和年龄
• @param n
• @param a
  */
  public Dog(String n,int a) {
  name = n;
  age = a;
  }
  }

public class Test {
public static void main(String[] args) {
Dog wangcai = new Dog();
System.out.println(wangcai.name + wangcai.age);
Dog [] dogs = {new Dog(“旺财”, 1),new Dog(“旺财”, 1),new Dog(“旺财”, 1)};
}
}

方法重载和方法重写的区别
方法的重写Overriding和重载Overloading是Java多态性的不同表现。
重写Overriding 是父类与子类之间多态性的一种表现，重载 Overloading 是一个类中多态性的一种表现。 如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Overriding)。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被“屏蔽”了。
如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载(Overloading)。Overloaded 的方法是可以改变返回值的类型。

1. 重载（Overloading）
   方法重载 （老师总结）

• 1、在同一个类中，可以有多个方法，但是参数列表不同的方法
• 2、参数列表不同：包含三种情况
• 参数个数不同
• 参数类型不同
• 不同类型的参数顺序不同
• 3、方法的重载使用在哪些场景
• 对不同类型的数据执行相同的操作
• 只有返回值类型不一样 不构成方法重载
• 只有形参的名称不同，不构成方法重载

2.重写（Overriding）
（1)父类与子类之间的多态性，对父类的方法进行重新定义。如果在子类中定义某
方法与其父类有相同的名称和参数，我们说该方法被重写。在 java中，子类可继承父类中的方 法，而不需要重新编写相同的方法。但有时子类并不想原封不动地继承父类的方法，而是想作一 定的修改，这就需要采用方法的重写。方法重写又称方法覆盖。
（2)若子类中的方法与父类中的某一方法具有相同的方法名、返回类型和参数表，
则新方法将覆盖原有的方法。如需父类中原有的方法，可使用super关键字，该
关键字引用了当前类的父类。

（3）重写方法必须和被重写方法具有相同方法名称、参数列表和返回类型。

（4)子类函数的访问修饰权限不能少于父类的；
1.封装

1.隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提高系统 的可扩展性、可维护性。
我们程序设计要追求“高内聚，低耦合”。
2.高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；
低耦合 ：仅暴露少量的方法给外部使用。

成员（成员变量或成员方法）访问权限共有四种：

public 公共的
可被同一项目中所有的类访问。 (必须与文件名同名)

protected 受保护的
可以被这个类本身访问；同一个包中的所有其他的类访问；被它的子类（同一个包以及不同包中的子类）访问
default／friendly 默认的/友好的（包可见性）
被这个类本身访问；被同一个包中的类访问。
private 私有的
只能被这个类本身访问。（类可见性）

访问权限 类 包 子类 其他包
public ∨ ∨ ∨ ∨
protect ∨ ∨ ∨ ×
default ∨ ∨ × ×
private ∨ × × ×

---

set和get就是用于设置和读取Java private变量的方法。这样子外部程序就不会直接访问程序的变量。只能通过set去设置值，用get去读取值。有利于对外封装。防止外部程序随意修改我们的变量。

2.继承

1.通过继承可以简化类的定义，实现代码的重用
2.子类继承父类的成员变量和成员方法，但不继承父类的构造方法
3.java中只有单继承。
4.java中的多继承，可以通过接口来实现
5.如果定义一个类时，没有调用extends（扩展），则它的父类是：
java.la