9.面向对象编程（中级）

最新推荐文章于 2024-09-01 15:30:33 发布

MrViolett

最新推荐文章于 2024-09-01 15:30:33 发布

阅读量48

点赞数

分类专栏：萌新的java之旅文章标签： java

本文链接：https://blog.csdn.net/qq_21565101/article/details/132695866

版权

萌新的java之旅专栏收录该内容

12 篇文章 0 订阅

订阅专栏

·基本介绍

面向对象编程有三大特征;封装、继承和多态

面对对象编程-封装

封装介绍

封装（encapsulation）就是把抽象出的数据[属性]和对数据的操作[方法]封装在一起，数据被保护在内部，程序的其他部分只有通过被授权的操作[方法],才能对数据进行操作。

·封装的理解和好处

1)隐藏实现细节

2)可以对数据进行验证，保证安全合理Person{name,age}

·封装的实现步骤

1)将属性进行私有化【不能直接修改属性】

2）提供一个公共的set方法，用于对属性判断并赋值

public void setXxx(类型参数名){

//加入数据验证的业务逻辑

属性 = 参数名;

}

3)提供一个公共的get方法，用于获取属性的值

public XX getXxx(){//权限判断

return xx;

}

package com.hspedu.encap;

public class Encapsulation01 {
    public static void main(String[] args) {
    	Person person = new Person();
    	person.setName("jack");
    	person.setAge(30);
    	person.setSalary(30000);
    	System.out.println(person.info());
    	
    }
}
class Person{
	public String name;//名字公开
	private int age;//age私有化
	private double salary;//..
	public String getName() {
		return name;
	}
	public void setName(String name) {
		//加入对数据的校验
		if(name.length()>=2 && name.length() <=6) {
		this.name = name;
		}else {
			System.out.println("名字长度不对,需要(2-6)个字符，默认名字");
			this.name="无名氏";
		}
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		//判断
		if(age >=1 && age <=120) {
		this.age = age;
		}else {
			System.out.println("年龄需要在（1-120），给默认年龄18");
			this.age=18;//给一个默认年龄
		}
	}
	public double getSalary() {
		//可以这里增加对当前权限查看
		return salary;
	}
	public void setSalary(double salary) {
		this.salary = salary;
	}
	//写一个方法，返回属性信息
	public String info() {
		return "信息为 name =" +name +"age ="+age+"薪水"+salary;
	}
	
}

面对对象编程-继承

·为什么需要继承

两个类的属性和方法有很多是相同的--》继承（代码复用性~）

·继承基本介绍和示意图

继承可以解决代码复用，让我们的编程更加靠近人类思维，当多个类存在相同的属性（变量）和方法时，可以从这些类中抽象出父类，在父类中定义这些相同的属性和方法,所有的子类不需要重新定义这些属性和方法，只需要extends来声明继承父类即可。

示意图

·继承的基本语法

class 子类 extends 父类{

}

1)子类就会自动拥有父类定义的属性和方法

2)父类又叫超类，基类

3)子类又叫派生类

package com.hspedu.encap.improve;

public class Student {
	//共有属性
	public String name;
	public int age;
	private double score;//成绩
	//共有的方法
	public void setScore(double score) {
		this.score = score;
	}
	public void showInfo() {
		System.out.println("学生名"+name+"年龄"+age+"成绩"+score);
	}
 
}

package com.hspedu.encap.improve;

public class Pupil extends Student {
   public void testing() {
	   System.out.println("大学生"+name+"正在考小学数学");
   }
}

·继承给编程带来的便利

1)代码的复用性提高了

2)代码的拓展性和维护性提高了

·继承的深入讨论/细节问题

1.子类继承了所有的属性和方法，非私有的属性和方法可以在子类直接访问，但是私有属性和方法不能在子类直接访问，要通过父类提供公共的方法去访问

2.子类必须调用父类的构造器，完成父类的初始化

3.当创建子类对象时，不管使用子类的哪个构造器，默认情况下总会去调用父类的无参构造器，如果父类没有提供无参构造器，则必须在子类的构造器中用super去指定使用父类的哪个构造器完成对父亲的初始化工作，否则，编译不会通过

4.如果希望指定去调用父亲的某个构造器，则显式的调用一下:super(参数列表)

5.super在使用时，必须放在构造器第一行（super只能在构造器中使用）

6.super()和this 都只能放在构造器第一行，因此这两个方法不能共存在一个构造器

7.java所有类都是Object类的子类，Object是所有类的基类

8.父亲构造器的调用不限于直接父亲！将一直往上追溯直到Object类(顶级父亲)

9.子类最多只能继承一个父亲(指直接继承),即java中是单继承机制。(多继承可以层层继承实现)

10.不能滥用继承，子类和父类之间必须满足is-a的逻辑关系

Person is a Music?

Person Mucis

Music extends Person

Animal

Cay extends Animal

继承本质详解

package com.hspedu.extend_;

public class ExtendsTheory {

	public static void main(String[] args) {
		Son son =new Son();//内存的分布
		//?->这时请大家注意，要注意查找关系来返回信息
		//(1)首先看子类是否有该属性
		//(2)如果子类有这个属性，并且可以访问，则返回信息
		//(3)如果子类没有这个属性，就看父类有没有这个属性(如果父类有该属性，并且可以访问，就返回信息...)
        //(4)如果父亲没有就按照(3)的规则，继续找上级父类，直到Object...
		System.out.println(son.name);//返回就是大头儿子
		//System.out.println(son.age);//返回就是39
		//System.out.println(son.getAge());//返回就是39
		System.out.println(son.hobby);//返回的就是旅游
	}

}
class GrandPa{//爷爷类
	String name = "大头爷爷";
	String hobby = "旅游";
	
}
class Father extends GrandPa{//父类
	String name = "大头爸爸";
	private int age =39;
	
	public int getAge() {
		return age;
	}
}
class Son extends Father{//子类
	String name = "大头儿子";
	
}

super关键字

·基本介绍

super代表父类的引用，用于访问父类的属性、方法、构造器

·基本语法

1.访问父类的属性，但不能访问父类的private属性

super.属性名;

2.访问父类的方法，不能访问父类的private方法

super.方法名(参数列表);

3.访问父类的构造器

super(参数列表);只能放在构造器的第一句，只能出现一句！

·super给编程带来的便利/细节

1.调用父类的构造器的好处(分工明确，父类属性由父类初始化，子类的属性由子类初始化)

2.当子类中有和父类中的成员(属性和方法)重名时，为了访问父类的成员，必须通过super。如果没有重名，使用super、this、直接访问是一样的效果！

3.super的访问不限于直接父类，如果爷爷类和本类中有同名的成员，也可以使用super去访问爷爷类的成员;如果多个基类(上级类)中都有同名的成员，使用super访问遵循就近原则：A-->B-->C，当然也需要遵循访问权限的规则

·super和this的比较

NO.	区别点	this	super
1	访问属性	访问本类中的属性，如果本类没有此属性则从父类中继续查找	从父类开始查找属性
2	调用方法	访问本类中的方法，如果本类没有方法则从父类继续查找	从父类开始查找方法
3	调用构造器	调用本类构造器，必须放在构造器的首行	调用父类构造器，必须放在子类构造器的首行
4	特殊	表示当前对象	子类中访问父类的对象

方法重写/覆盖(Override)

简单的说：方法覆盖(重写)就是子类有一个方法，和父类的某个方法的名称、返回类型、参数一样，那么我们就说子类的这个方法覆盖了父亲的方法

·注意事项和使用细节

方法重写也叫方法覆盖，需要满足下面的条件

1.子类的方法形参参数，方法名称，要和父亲方法的形参参数，方法名称完全一样。

2.子类方法和返回类型和父类方法返回类型一样，或者是父亲返回类型的子类

比如父类返回类型是Object，子类方法返回类型是String

3.子类方法不能缩小父类方法的访问权限 public > protected > 默认 > private

多态

代码的复用性不高，而且不利于代码维护--->多态

方法或对象具有多种形态。是面向对象的第三大特征，多态是建立在封装和继承基础之上的。

1.方法的多态

重写和重载就体现多态

2.对象的多态（核心，困难，重点）

重要的几句话（记住）：

(1)一个对象的编译类型和运行类型可以不一致

(2)编译类型在定义对象时，就确定了，不能改变

(3)运行类型是可以变化的

(4)编译类型看定义时 = 号的左边，运行类型看 = 号的右边

package com.hspedu.poly_;

public class Master {
  private String name;
  public Master(String name ) {
	  this.name=name;
  }
public String getName() {
	return name;
}
public void setName(String name) {
	this.name = name;
}
//使用多态机制，可以统一的管理主人喂食的问题
//animal编译类型是Animal,可以指向(接收)Animal子类的对象
//food编译类型是Food,可以指向（接收）Food子类的
public void feed(Animal animal,Food food) {
	System.out.println("主人"+name+"给"+animal.getName()+"吃"+food.getName());
}
}

·多态注意事项和细节讨论

√多态的前提是：两个对象(类)存在继承关系

√多态的向上转型

1)本质：父类的引用指向了子类的对象

2)语法：父亲类型引用名 = new 子类类型();

3)特点：编译类型看左边,运行类型看右边。

可以调用父类中的所有成员(需遵循访问权限)，

不能调用子类中特有成员;

最终运行效果看子类的具体实现！

package com.hspedu.poly_.detail_;

public class PolyDetail {

	public static void main(String[] args) {
		//向上转型：父类的引用指向了子类的对象
		//语法：父类类型引用名 = new 子类类型();
		Animal animal = new Cat();
		Object obj = new Cat();
		//向上转型调用方法的规则如下：
		//(1)可以调用父类中的所有成员（需遵守访问权限）
		//(2)但是不能调用子类的特有的成员
		//(3)因为编译阶段，能调用哪些成员，是由编译类型来决定的
		//animal.catchMouse();错误
		//(4)最终运行效果看了类（运行类型）的具体实现，即调用方法时，按照子类（运行类型）开始查找方法
		//然后调用，规则我前面我们讲的方法调用规则一致。

	}

}

√多态的向下转型

1)语法:子类类型引用名 = （子类类型）父类引用;

2)只能强转转父类的引用，不能强转父类的对象

3)要求父类的引用必须指向的是当前目标类型的对象

4)当向下转型后，可以调用子类类型中所有的成员

Cat cat = (Cat) animal;
        cat.catchMouse();//猫抓老鼠

√属性没有重写之说！属性的值看编译类型

√instanceOf 比较运算符，用于判断对象的运行类型是否为XX类型或XX类型的子类型

package com.hspedu.poly_.detail_;

public class PolyDetail03 {

	public static void main(String[] args) {
		BB bb = new BB();
		System.out.println(bb instanceof BB);//true
		System.out.println(bb instanceof AA);//true
		//aa 编译类型 AA ,运行类型是BB
		AA aa = new BB();
		System.out.println(aa instanceof AA);
		System.out.println(aa instanceof BB);
		Object obj = new Object();
		System.out.println(obj instanceof AA);//false
		String str = "hello";
		//System.out.println(str instanceof AA);
		System.out.println(str instanceof Object);//true
		
		
	}

}
class AA{}//父类
class BB extends AA {//子类
	
}

java的动态绑定机制（非常非常重要）

1.当调用对象方法的时候，该方法会和该对象的内存地址/运行类型绑定

2.当调用对象属性时，没有动态绑定机制，哪里声明，哪里使用

package com.hspedu.poly_.dynamic_;

public class DynamicBinding {

	public static void main(String[] args) {
		A a = new B();//向上转型
		System.out.println(a.sum());//40
		System.out.println(a.sum1());//30

	}

}
class A{//父类
	public int i =10;
	public int sum() {
		return getI()+10;
	}
	public int sum1() {
		return i +10;
		
	}
	public int getI() {
		return i ;
	}
	
}
class B extends A{//子类
	public int i =20;
//	public int sum() {
//		return i + 20;
//	}
	public int getI() {
		return i;
	}
//	public int sum1() {
//		return i +10;
//	}
}

·多态的应用

(1)多态数组

数组的定义类型为父类类型，里面保存的实际元素类型为子类类型

package com.hspedu.poly_.polyarr;

public class PolyArray {

	public static void main(String[] args) {
		Person[] persons = new Person[5];
		persons[0] = new Person("jack",20);
		persons[1] = new Student("jack",18,100);
		persons[2] = new Student("smith",19,30.1);
		persons[3] = new Teacher("scott",30,20000);
		persons[4] = new Teacher("king",50,25000);
		//循环遍历多态数组，调用say
		for (int i =0;i<persons.length;i++) {
			//老师提示：persons[i] 编译类型是 Person, 运行类型是根据实际情况有JVM来判断
			System.out.println(persons[i].say());//动态绑定机制
		
		if(persons[i] instanceof Student) {
			Student student =(Student)persons[i];//向下转型
			student.study();
			//也可以使用一条语句((Student)person[i]).study();
			
		}else if(persons[i] instanceof Teacher) {
			Teacher teacher = (Teacher)persons[i];
			teacher.teach();
		}else if(persons[i] instanceof Person){
			//
		}else {
			System.out.println("你的类型有误，请自己检查.");
		}
		

	}

}
}

2）多态参数

方法定义的形参类型为父类类型，实参类型允许为子类类型

·equals方法

==和equals的对比

==是一个比较运算符

== :既可以判断基本类型，又可以判断引用类型
==：如果判断基本类型，判断的是值是否相等。示例：int i =10;double d =10.0;
==：如果判断引用类型，判断的是地址是否相等，即判断是不是同一个对象
equals:是Object类中的方法，只能判断引用类型
默认判断的是地址是否相等，子类中往往重写该方法，用于判断内容是否相等。比如Integer,String

package com.hspedu.object_;

public class Equals01 {

	public static void main(String[] args) {
		A a = new A();
		A b =a ;
		A c =b;
		System.out.println(a == c);//true
		System.out.println(b == c);//true
		B obj =a ;
		System.out.println(obj == c);//true
		int num1 = 10;
		double num2 =10.0;
		System.out.println(num1 == num2);//基本数据类型，判断值是否相等
		//equals 方法，源码怎么查看.
//		public boolean equals(Object anObject) {
//        if (this == anObject) {
//            return true;
//        }
//        return (anObject instanceof String aString)
//                && (!COMPACT_STRINGS || this.coder == aString.coder)
//                && StringLatin1.equals(value, aString.value);
//    }

		"hello".equals("abc");
		Integer integer1 = new Integer(1000);
		Integer integer2 = new Integer(1000);
		System.out.println(integer1 == integer2);//false
		System.out.println(integer1.equals(integer2));//true
		String str1 =new String("hspedu");
		String str2 = new String("hspedu");
		System.out.println(str1 == str2);
	}
}
	class A extends B{}
	class B{}

·hashCode方法

1)提高具有哈希结构的容器的效率!

2)两个引用，如果指向的是同一个对象，则哈希值肯定是一样的!

3)两个引用，如果指向的是不同对象，则哈希值是不一样的

4)哈希值主要根据地址号来的!,不能完全将哈希值等价于地址。

6)后面在集合，中hashCode如果需要的话，也会重写(集合时)

package com.hspedu.object_;

public class HashCode {

	public static void main(String[] args) {
		AA aa =new AA();
		AA aa2 =new AA();
		AA aa3 = aa;
		System.out.println(aa.hashCode());
		System.out.println(aa2.hashCode());
		System.out.println(aa3.hashCode());

	}
	

}
class AA {}

·toString

√基本介绍

默认返回：全类名+@+哈希值的十六进，【查看Object的 toString方法】

子类往往重写toString方法，用于返回对象的属性信息

√重写toString方法，打印对象或拼接对象时，都会自动调用该对象的toString形式.

√当直接输出一个对象时，toSting方法会被默认的调用,比如

System.out.println(monster); 就会默认调用 monster.toString()

package com.hspedu.object_;

public class ToString {

	public static void main(String[] args) {
//		  public String toString() {
//		        return getClass().getName() + "@" + Integer.toHexString(hashCode());
//		    }
     Monster monster=new Monster("小妖怪","巡山的",1000);
     System.out.println(monster.toString());
     System.out.println(monster);

	}

}
class Monster{
	private String name;
	private String job;
	private double sal;
	public Monster(String name, String job, double sal) {
		super();
		this.name = name;
		this.job = job;
		this.sal = sal;
	}
	@Override
	public String toString() { //重写后，一般是把对象的属性值输出，当然程序员也可以自己定制
		return "Monster [name=" + name + ", job=" + job + ", sal=" + sal + "]";
	}
}

·finalize方法

1.当对象回收时，系统自动调用该对象的finalize方法。子类可以重现该方法,做一些释放资源的操作

2.什么时候回收：当某个对象没有任何引用时，则jvm就认为这个对象时一个垃圾对象，就会使用垃圾回收机制来销毁该对象，在销毁该对象前，会先调用finalize方法。

3.垃圾回收机制的调用，是由系统来决定，也可以通过System.gc() 主动触发垃圾回收机制，

断点调试

·一个实际需求

1.在开发中，新手程序员在查找错误时，这时老程序员就会温馨提示，可以用断点调试，一步一步的看源码执行的过程，从而发现错误所在。

2.重要提示：在断点调试过程中，是运行状态，是以对象的运行类型来执行的.

·断点调试介绍

1.断点调试是指在程序的某一行设置一个断点，调试时，程序运行到这一行就会停住，然后你可以一步一步往下调试，调试过程中可以看各个变量当前的值，出错的话，调试到出错的代码行即显示错误，停下。进行分析从而找到这个Bug

2.断点调试时程序员必须掌握的技能。

3.断点调试也能帮助我们查看java底层源代码的执行过程，提高程序员的Java水平。