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

⭐️大一小何，还在学习当中，欢迎交流指正~  

三篇文章带你面向对象 

1.

java之面向对象1_快乐的小何~的博客-CSDN博客

2 .

java之面向对象2_快乐的小何~的博客-CSDN博客https://blog.csdn.net/qq_61430041/article/details/122619492?spm=1001.2014.3001.5501

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

 冲冲冲~