欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识！
您现在的位置是： 首页

10 面对对象-中篇

程序员文章站 2022-06-01 13:02:32
...

1 包

现在有两个程序员共同开发一个java项目,程序员xiaoming希望定义一个类取名 Dog ,程序员xiaoqiang也想定义一个类也叫 Dog。两个程序员为此还吵了起来,怎么办?

1.1 包的三大作用

  1. 区分相同名字的类
  2. 当类很多时,可以很好的管理类
  3. 控制访问范围

1.2 打包命令

打包基本语法
package com.atguigu;
说明: package 关键字,表示打包.
com.atguigu: 表示包名
打包的本质分析(原理)
实际上就是创建不同的文件夹来保存类文件，
命名规则：
只能包含数字、字母、下划线、小圆点.,但不能用数字开头，不能是关键字或保留字
demo.class.exec1 //错误
demo.12a //

命名规范：
一般是小写字母+小圆点一般是
com.公司名.项目名.业务模块名
举例:
com.sina.crm.user //用户模块
com.sina.crm.order // 订单模块
com.sina.crm.utils //工具类

1.3 常用的包

一个包下,包含很多的类,java中常用的包有:
java.lang.* //lang包是基本包，默认引入，不需要再引入.
java.util.* //util 包，系统提供的工具包, 工具类，使用
java.net.* //网络包，网络开发
java.awt.* //是做java的界面开发，GUI

1.4 如何引入包

语法: import 包;
比如 import java.awt.*; // * 表示将该包的所有类和接口引入.
我们引入一个包的主要目的是要使用该包下的类
比如 import java.util.Scanner; 就只是引入一个类Scanner。

1.5 注意事项

1)package 的作用是声明当前类所在的包，需要放在class的最上面，一个类中最多只有一句package
2)import指令 位置放在class的上面，package的下面，可以有多句且没有顺序要求

2 访问修饰符

2.1 基本介绍

java提供四种访问控制修饰符号控制方法和变量(属性、字段)的访问权限（范围）:
1)公开级别:用public 修饰,对外公开
2)受保护级别:用protected修饰,对子类和同一个包中的类公开
3)默认级别:没有修饰符号,向同一个包的类公开.
4)私有级别:用private修饰,只有类本身可以访问,不对外公开.

2.2 4种访问修饰符的访问范围

10 面对对象-中篇

2.3 使用的注意事项

1)修饰符可以用来修饰类中的属性，成员方法以及类
2)只有默认的和public才能修饰类！，并且遵循上述访问权限的特点。
3)因为没有学习继承，因此关于在子类中的访问权限，我们讲完子类后，在回头讲解
4)成员方法的访问规则和属性一样.

3 面向对象编程三大特征

3.1 基本介绍

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

3.2 封装介绍

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

3.2.1 封装的理解和好处

1)隐藏实现细节
2)提可以对数据进行验证，保证安全合理

3.2.2 如何体现封装

1)对类中的属性进行封装
2)通过成员方法，包实现封装

3.2.3 封装的实现步骤

1)将属性进行私有化
2)提供一个公共的set方法，用于对属性判断并赋值

public void setXxx(类型 参数名){
		//加入数据验证的业务逻辑
		属性 = 参数名;
	}

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

public XX getXxx(){
		return xx;
    }

3.2.4 快速入门案例

public class Person {
	public String name;
	private short age;
	private double sal;
	private String job;
	
	//一般来说，一个类会有构造器
	//构造器+setXxx结合使用
	public Person(String name, short age, double sal, String job) {
		
		this.setName(name);
		this.setAge(age);
		this.setJob(job);
		this.setSal(sal);
	}
	
	public Person() {}
	
	//对这些属性提供setXxx和getXxx的方法
	//shift + alt + s => 选择生成set和get
	public String getName() {
		return name;
	}
	
	public void setName(String name) {
		this.name = name;
	}
	public short getAge() {
		return age;
	}
	public void setAge(short age) {
		//提可以对数据进行验证，保证安全合理
		if (age > 0 && age < 120) {
			this.age = age;
		}else {
			//给一个默认值
			this.age = 18;
		}
	}
	public double getSal() {
		return sal;
	}
	public void setSal(double sal) {
		this.sal = sal;
	}
	public String getJob() {
		return job;
	}
	public void setJob(String job) {
		this.job = job;
	}
	
	
	//在每个类中，有一个方法，叫toString() 
	//当我们直接输出一个对象时，系统会默认调用toString()
	//因此在开发中，经常使用这个方法输出对象信息
	public String toString() {
		return "Person [name=" + name + ", age=" + age + ", sal=" + sal + ", job=" + job + "]";
	}
	
	
}

public class TestPerson {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Person person = new Person();
		person.name = "jack";
		person.setAge((short)300);
		//输出一个peron的信息
		System.out.println(person);
		
		Person person2 = new Person("tom", (short)3000, 34.5, "javaee程序员");
		System.out.println("person2=" + person2);	
	}
}

3.3 面向对象编程-继承

3.3.1 为什么需要继承

我们编写了两个类，一个是Pupil 类(小学生)，一个是Graduate(大学生).
问题 ： 两个类的属性和方法有很多是相同的，怎么办 => 继承(代码复用性~)

//小学生
public class Pupil {
	public String name;
	private short age;
	private float score;
	
	
	public void testing() {
		System.out.println("小学生在考试 小学语文~~");
	}
	public void showInfo() {
		System.out.println(this.name + " 成绩 " + this.score);
	}
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public short getAge() {
		return age;
	}
	public void setAge(short age) {
		this.age = age;
	}
	public float getScore() {
		return score;
	}
	public void setScore(float score) {
		this.score = score;
	}
	
	
}

public class Graduate {

	public String name;
	private short age;
	private float score;
	
	public void testing() {
		System.out.println("大学生在考试 微积分~~");
	}
	public void showInfo() {
		System.out.println(this.name + " 成绩 " + this.score);
	}
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public short getAge() {
		return age;
	}
	public void setAge(short age) {
		this.age = age;
	}
	public float getScore() {
		return score;
	}
	public void setScore(float score) {
		this.score = score;
	}
}

3.3.2 继承基本介绍和示意图

继承可以解决代码复用,让我们的编程更加靠近人类思维.当多个类存在相同的属性(变量)和方法时,可以从这些类中抽象出父类(比如刚才的Student),在父类中定义这些相同的属性和方法，所有的子类不需要重新定义这些属性和方法，只需要通过extends语句来声明继承父类即可。
画出继承的示意图
10 面对对象-中篇

3.3.3 继承的基本语法

class 子类 extends 父类{
}

1)子类就会自动拥有父类定义的属性和方法
2)父类又叫 超类，基类。
3)子类又叫派生类

3.3.4 快速入门案例


public class Student {
	public String name;
	private short age;
	private float score;
	
	public void showInfo() {
		System.out.println(this.name + " 成绩 " + this.score);
	}
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public short getAge() {
		return age;
	}
	public void setAge(short age) {
		this.age = age;
	}
	public float getScore() {
		return score;
	}
	public void setScore(float score) {
		this.score = score;
	}
}

//小学生
public class Pupil extends Student {
	
	
	public void testing() {
		System.out.println("小学生在考试 小学语文~~");
	}
	
}

public class Graduate extends Student{

	
	public void testing() {
		System.out.println("大学生在考试 微积分~~");
	}
	
	
}

public class TestExtends {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Pupil pupil = new Pupil();
		pupil.setName("jack");
		pupil.testing();
		pupil.setScore(78);
		pupil.showInfo();
		
		Graduate graduate = new Graduate();
		graduate.setName("smith");
		graduate.testing();
		graduate.setScore(99.9f);
		graduate.showInfo();
		
	}

}

继承给编程带来的便利
1)代码的复用性提高了
2)代码的扩展性和维护性提高了

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

  1. 子类继承了所有的属性和方法，只是私有的属性不能直接访问，需要通过公共的方法去访问
    2)子类没有继承父类的构造器，但必须调用父类的构造器， 完成父类的初始化
    3)当创建子类时，不管你使用子类的哪个构造方法，默认情况下总会去调用父类的无参构造函数，如果父类没有提供无参构造函数，则必须在子类的构造函数中用 super 去指定使用父类的哪个构造函数完成对父类的初始化工作，否则，编译不会通过
    4)如果希望指定去调用父类的某个非默认构造方法，则显示的调用一下
    5)super在使用时，需要放在方法体的第一句位置
    6)super() 和 this() 都只能放在构造方法句首，因此这两个函数不能共存在一个方法中
    7)java所有类都是Object类的子类
    8)父类构造器的调用不限于直接父类！将一直往上追溯直到Object类
    9)子类最多只能继承一个父类(指直接继承)，即java中是单继承机制。
    10)不能滥用继承，子类和父类之间必须满足 is-a 的逻辑关系

继承的本质分析

public class ExtendsTheory {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Son son = new Son();
		System.out.println("son=" + son);

	}

}

class GrandPa {
	String name = "段大爷";
	String hobby = "遛鸟";
}
class Father extends GrandPa {
	
	String name = "段正存";
	int  age = 40;
	
}
class Son extends Father {
	String name = "段誉";
}

10 面对对象-中篇

4 super关键字

4.1 基本介绍

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

4.2 基本语法

访问父类的属性 , 不能访问父类的private属性 [案例]
super.属性名;
2) 访问父类的方法，不能访问父类的private方法
super.方法名(参数列表);
3)访问父类的构造器(这点前面用过)：
super(参数列表);只能放在构造器的第一句，而且只能出现一句！

4.3 super给编程带来的便利

调用父类的构造器 （分工明确, 父类属性由父类初始化，子类的属性由子类初始化）
3)当子类中有和父类中的成员（属性和方法）重名时，为了访问父类的成员，必须通过super。如果没有重名，使用super、this、直接访问是一样的效果！ [举例]
4)super的访问不限于直接父类，如果爷爷类和本类中有同名的成员，也可以使用super去访问爷爷类的成员；如果多个基类中都有同名的成员，使用super访问遵循就近原则。

4.4 super和this的比较

10 面对对象-中篇

5 面向对象编程-多态

5.1多[多种]态[状态](polymorphic)基本介绍

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

5.2 多态的具体体现

方法的多态
重写和重载
10 面对对象-中篇
重写体现的多态


public class PolyDemo02 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		B b = new B();
		A a = new A();
		
		//因为我们的对象不一样，所有同样是say,但是调用的方法其实不一样.
		b.say(); // B say()
		a.say(); // A say()
		
		a = b; 	//让b 赋给 a
		//这里同样是a ,但是因为我们的a 指向不同对象地址时，就调用了不同的方法->多态
		a.say(); // B say()

	}

}

class A {
	public void say() {
		System.out.println("A say()");
	}
}

class B extends A {
	@Override
	public void say() {
		// TODO Auto-generated method stub
		System.out.println("B say()");
	}
}

5.3 对象的多态

一个对象的编译类型和运行类型不一致
Animal animal = new Dog(); 【Animal animal 就是编译类型，而 new Dog() 就是运行类型】
10 面对对象-中篇

public class PolyDemo03 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//对象的多态体现
		
		//说明
		//1. 在java中 ，允许将一个子类的对象实例,赋给父类的一个引用.
		//2. 在编译时 animal 是 Animal 类型, 这个就是要编译类型
		//   此时 animal 引用只能调用Animal 方法.
		//3. 在运行时  animal 其实是Dog 类型， 这个就是运行类型
		Animal2 animal = new Dog2();
		

	}

}


class Animal2 {
	public void run() {
		System.out.println("running..");
	}
}

class Dog2 extends Animal2 {
	
	public void play() {
		System.out.println("playing..");
	}
	
}

5.4 多态快速入门案例

public class PolyDemo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Master master = new Master("jack");
		Fish fish = new Fish("黄花鱼");
		Cat cat = new Cat("小花猫");
		Bone bone = new Bone("大棒骨");
		Dog dog = new Dog("小黄狗");
		
		master.feed(cat, fish);
		master.feed(dog, bone);
		
		Tiger tiger = new Tiger("东北虎");
		Meat meat = new Meat("羊肉");
		
		master.feed(tiger, meat);
	}

}


class Master {
	private String name;

	public Master(String name) {
		super();
		this.name = name;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
	
	//feed 待定..
	/*
	//主人给猫喂鱼吃
	public void feed(Cat cat, Fish fish) {
		System.out.println(this.name + " 给" + cat.getName() + " 喂" + fish.getName());
	}
	//主人给狗喂骨头
	public void feed(Dog dog, Bone bone) {
		System.out.println(this.name + " 给" + dog.getName() + " 喂" + bone.getName());
	}
	//主人给猪。。设计模式..
	 */
	//使用多态机制来解决feed
	public void feed(Animal animal , Food food) {
		System.out.println(this.name + " 给" + animal.getName() + " 喂" + food.getName());
	}
	
	
}

class Animal {
	private String name;

	public Animal(String name) {
		super();
		this.name = name;
	}

	public String getName() {
		return name;
	}

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

class Cat extends Animal{
	public Cat(String name) {
		super(name);
	}
}

class Dog extends Animal{
	public Dog(String name) {
		super(name);
	}
}

class Tiger extends Animal {

	public Tiger(String name) {
		super(name);
		// TODO Auto-generated constructor stub
	}
	
}

class Food {
	private String name;

	public Food(String name) {
		super();
		this.name = name;
	}

	public String getName() {
		return name;
	}

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

class Fish extends Food{

	public Fish(String name) {
		super(name);
		// TODO Auto-generated constructor stub
	}
	
}

class Bone extends Food {

	public Bone(String name) {
		super(name);
		// TODO Auto-generated constructor stub
	}
	
}

class Meat extends Food {

	public Meat(String name) {
		super(name);
		// TODO Auto-generated constructor stub
	}
	
}

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

多态的前提是：两个对象(类)存在继承关系
多态的向上转型
本质：父类的引用指向了子类的对象
1)语法：父类类型 引用名 = new 子类类型();
2)特点：编译看左边，运行看右边。可以调用父类类型中的所有成员，不能调用子类类型中特有成员；
3)最终运行效果看子类的具体实现！

多态的向下转型
1)语法：子类类型 引用名 = （子类类型）父类引用;
2)只能强转父类的引用，不能强转父类的对象
3)要求父类的引用必须指向的是当前目标类型的对象
4)可以调用子类类型中所有的成员

属性没有重写之说！属性的值看编译类型,即属性没有动态绑定机制.
instanceOf 比较操作符，用于判断某个对象的类型是否为XX类型或XX类型的子类型

5.6 java的动态绑定机制

Java另一重要特性: 动态绑定机制
1)当调用对象方法的时候，该方法会和该对象的内存地址绑定
2)当调用对象属性时，没有动态绑定机制，哪里声明，那里使用

相关标签： java核心

上一篇： 数羊数睡了

下一篇： 这也是个人才

推荐阅读