Java 之面向对象 3（终结篇）

一，封装，继承

封装

继承

二，构造器

三，方法的重写

四，四种权限修饰符

五，package 关键字

六，this . 关键字

七，import 关键字

八，static 关键字

结语

一，封装，继承封装把对象的属性和方法结合成一个独立的整体，隐藏实现细节，并提供对外访问的接口。

封装的优点：

1.隐藏实现细节。

2.安全性。

比如你在程序中私有化了 age 属性，并提供了对外的 get 和 set 方法，当外界 使用 set 方法为属性设值的时候 你可以在 set 方法里面做个 if 判断，把值设值在 0-80 岁，那样他就不能随意赋值了。啊哈~

3.增加代码复用性。

比如在工具中封装的各种方法，可以任意调用，而不用每处去实现细节。

4.模块化。

封装分为封装属性，方法，类等等。有利于代码调试，相互配合。

封装性的体现:我们将类的属性 xxx 私有化(private),同时，提供公共的(public)方法来获取(getXxx)和设置(setxxx)拓展:封装性的体现:如上不对外暴露的私有的方法③单例模式...

封装性的体现，需要权限修饰符来配合。

1.Java 规定的 4 种权限（从小到大排列): private、缺省、protected . public

2.4 种权限可以用来修饰类及类的内部结构:属性、方法、构造器、内部类 3.具体的，4 种权限都可以用来修饰类的内部结构:属性、方法、构造器、内部类修饰类的话，只能使用:缺省、public

封装性:Java 提供了 4 种权限修饰符来修饰类及类的内部结构，体现类及类的内部结构在被调用时的可见性的;

具体表现：

1.属性使用 private 权限 2.方法使用 public 权限

封装的步骤

1. 修改属性的可见性来限制对属性的访问（一般限制为 private）

2. 对每个值属性提供对外的公共方法访问，也就是创建一对赋取值方法，用于对私有属性的访问

3.重写从父类 Object 继承下来的 toString()方法，来输出自己想要的信息。

4.重写从父类 Object 继承的 hashCode()方法，计算 hashCode 值，hashCode 值主要用来判断对象的属性是否相同，进行数组的排序。

5.重写从父类 Object 继承的 equals()方法，判断两个对象属性值是否完全相同

like this:

public class User {

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;}

}

//下文介绍 this.关键字

继承继承的概念：从已知的一个类中派生出一个新的类，叫子类。子类实现了父类所有非私有化的属性和方法，并根据实际需求扩展出新的行为。

继承的好处：

1.继承是传递的，易于在其基础上构造和扩充。

2.简化对事物的描绘，使得层次更加清晰。

3.减少代码冗余。

4.提高可维护性。

（多态）敬请期待。。。

二，构造器构造器的作用:

1.创建对象

2.初始化对象的信息

二、说明:1.如果没有显式的定义类的构造器的话，则系统默认提供一个空参的构造器

2.定义构造器的格式:权限修饰符类名(形参列表){ }

3.一个类中定义的多个构造器，彼此构成重载

4.一旦我们显式的定义了类的构造器之后，系统就不再提供默认的空参构造器 5.一个类中，至少会有一个构造器。

构造器的特征 1.它具有与类相同的名称

2.它不声明返回值类型。(与声明为 void 不同)

3.不能被 static、final、synchronized、abstract、native 修饰，不能有 return 语句返回值

构造器的最大用处就是在创建对象时，对对象的实例进行初始化，那么构造器又分为有参构造和无参构造

理解有参和无参构造

package Work2;

//无参构造方法

public class Point {    int x;     int y;        public void movePoint(int dx,int dy){

// this.x += dx;this.x = this.x+dx;// this.y += dy;this.y = this.y+dy;}

  public static void main(String[] args){
    Point p = new Point();    p.movePoint(2, 6);    System.out.println("pX轴的坐标为："+p.x+"\n" + "PY轴的坐标为 ：" + p.y);      }}

上面采用的是默认的无参构造，因为类里面有默认的无参构造器

package happy;
  public class Point {      int x;       int y;      //创建一个无参构造器      public Point(){                  }             //创建一个有参构造器      public Point(int x0, int y0){        this.x = x0;        this.y = y0;      }          public void movePoint(int dx,int dy){//        this.x += dx;        this.x = this.x+dx;//        this.y += dy;        this.y = this.y+dy;      }      public static void main(String[] args){      Point p1 = new Point(2,2);      p1.movePoint(3,6);      System.out.println("p1x轴的坐标为:" + p1.x +"\n" + "p1y轴的坐标为："+p1.y);            Point p2 = new Point();      p2.movePoint(2, 6);      System.out.println("p2X轴的坐标为："+p2.x+"\n" + "P2Y轴的坐标为 ：" + p2.y);          }  }

三，方法的重写

定义:在子类中可以根据需要对从父类中继承来的方法进行改造，也称为方法的重置、覆盖。在程序执行时，子类的方法将覆盖父类的方法

要求:1．子类重写的方法必须和父类被重写的方法具有相同的方法名称、参数列表

2．子类重写的方法的返回值类型不能大于父类被重写的方法的返回值类型

父类被重写的方法的返回值类型是 void，则子类重写的方法的返回值类型只能是 void

父类被重写的方法的返回值类型是 A 类型，则子类重写的方法的返回值类型可以是 A 类或 A 类的子类

父类被重写的方法的返回值类型是基本数据类型(比如:double)，则子类重写的方法的返回值类型必须是相同的（double）

3．子类重写的方法使用的访问权限不能小于父类被重写的方法的访问权限子类不能重写父类中声明为 private 权限的方法 4.子类方法抛出的异常不能大于父类被重写方法的异常

注意:子类与父类中同名同参数的方法必须同时声明为非 static 的(即为重写)，或者同时声明为 static 的（不是重写）。因为 static 方法是属于类的，子类无法覆盖父类的方法。

约定俗称:子类中的叫重写的方法，父类中的叫被重写的方法

四，四种权限修饰符 Java 权限修饰符 public、protected、(缺省)、private 置于类的成员定义前，用来限定对象对该类成员的访问权限。

四种权限修饰符用法

关系：

对于 class 的权限修饰只可以用 public 和 ldefault(缺省)。public 类可以在任意地方被访问。default 类只可以被同一个包内部的类访问。

举个栗子

publ1c class order Test {public static void main( String[] args) {Order order = new Order();order. orderDefault = 1;order.orderProtected = 2;order. orderPublic = 3;

    order.methodDefault();    order.methodProtected();    order.methodPublic();    //同一个包中的其他类，不可以调用Order类中私有的属性、方法
    order.orderPrivate = 4;（哒咩）    order.methodPrivate( );（哒咩）}

}

同一个包中的其他类，不可以调用 Order 类中私有的属性、方法

在不同包的子类中，不能调用 Order 类中声明为 private 和缺省权限的属性、方法

不同包下的普通类(非子类）要使用 Order 类，不可以调用声明为 private、缺省、protected 权限的属性、方法

五，package 关键字 package 关键字的使用

1.为了更好的实现项目中类的管理，提供包的概念

2.使用 package 声明类或接口所属的包，声明在源文件的首行

3.包，属于标识符，遵循标识符的命名规则、规范(XXXYyyzzz)、“见名知意”

4.每”."一次，就代表一层文件目录。

补充:同一个包下，不能命名同名的接口、类。不同的包下，可以命名同名的接口、类。

六，this . 关键字 this 关键字的意义被解释为“指向当前对象的引用”

1、this：表示自身对象，也就是本对象自己

2、this.属性名：表示本对象自己的属性

3、this.方法名：表示本对象自己的方法

4、this(参数)表示本对象自身的构造方法(注：”构造方法”这个概念是相对于”类”而言的，但具体到 this(参数)这种用法时，表示”我这个对象自己的构造方法”)

5、外部类名.this.属性：表示在内部类中调用的是外部类的某个属性(调用外部类方法亦同)

用法如下

比如下面这个

把构造方法的参数名称修改为 name、age 和 height

运行结果是这样

因为，修改了构造方法之后，当我们调用构造方法创建对象时，给构造方法所传递的 3 个参数值“张三”、20 和 178.5 最终并没有赋值到对象的 3 个属性中。那么，既然参数值没有被赋值到对象的属性中，它们去了哪里呢？修改代码后，构造方法的参数与类所定义的属性同名，根据”同名情况下，局部变量的优先级更高”原则，在构造方法执行的过程中，虚拟机会把参数值赋给”参数本身”，而不是赋值给对象的属性！具体来说，就是我们给构造方法的 name 参数传递的值是”张三”，而这个”张三”在构造方法执行的过程中，当运行到”name=name;”这条语句时，并没有把”张三”赋值给对象的 name 属性，而是又重新赋值给了 name 参数自身。就是因为”张三”最终没有被赋值到对象的 name 属性中，才导致 introduce 方法中打印出的 name 属性是 null。当然，age 和 height 这两个参数也是同样的赋值效果。

我们在构造方法中，给”=”左边的属性前面都加上了 this 关键字，经过修改之后，重新运行 main 方法，就恢复了正常的运行效果。好，现在我们就来探究一下，加了 this 关键字之后，为什么程序能够”恢复正常”。刚才我们说过，”this”可以被解释为” 本对象自己的...”，按照这个逻辑，”this.name”就可以被解释为”本对象自己的 name 属性”，所以在执行”this.name=name;”这条语句的时候，虚拟机就会把 name 参数的值”张三”赋值给对象的 name 属性。也就是说在这条赋值语句中，”=”左边的”this.name”表示对象的 name 属性，而”=”右边的 name 表示方法的 name 参数。

七，import 关键字注意:1.在源文件中使用 import 显式的导入指定包下的类或接口 2.声明在包的声明和类的声明之间。

3.如果需要导入多个类或接口，那么就并列显式多个 import 语句即可

4.举例:可以使用 java.util.*的方式，一次性导入 util 包下所有的类或接口。

5.如果导入的类或接口是 java.lang 包下的，或者是当前包下的，则可以省略此 import 语句。

6.如果在代码中使用不同包下的同名的类。那么就需要使用类的全类名的方式指明调用的是哪个类。

7.如果已经导入 java.a 包下的类。那么如果需要使用 a 包的子包下的类的话，仍然需要导入。

8. import static 组合的使用:调用指定类或接口下的静态的属性或方法

例如

从 Java API 导入 Scanner 类：

import java.util.Scanner;

class MyCode {public static void main(String[] args) {Scanner myObj = new Scanner(System.in);System.out.println("Enter username");

String userName = myObj.nextLine();System.out.println("Username is: " + userName);

}}八，static 关键字被 static 修饰的变量和方法称为静态变量和静态方法

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

类名.静态类成员

创建静态属性和静态变量

public class xiaoheshimeinv{

static double PI = 3.14;//在类中定义静态变量
public static void method(){   //在类中定义静态方法    System.out.println("this is 静态变量");}
public static void main(String[] args){
System.out.println(xiaoheshimeinv.PI);//调用静态变量xiaoheshimeinv.method();//调用静态方法}

}

运行结果在此

3.14

this is 静态方法

结语光阴易逝，岂容我待。

参考书籍：《Java 核心卷 1》，《Java 从入门到精通》

参考视频：尚硅谷 Java 入门视频教程

视频链接：尚硅谷 Java 入门视频教程(在线答疑+Java 面试真题)_哔哩哔哩_bilibili

冲冲冲~