10 面对对象-中篇

最新推荐文章于 2021-06-29 14:55:14 发布

andyonlines

最新推荐文章于 2021-06-29 14:55:14 发布

阅读量142

点赞数

分类专栏： java核心

本文链接：https://blog.csdn.net/andyonlines/article/details/103739585

版权

java核心专栏收录该内容

10 篇文章 0 订阅

订阅专栏

1 包

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

1.1 包的三大作用

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

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种访问修饰符的访问范围

在这里插入图片描述

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语句来声明继承父类即可。
画出继承的示意图
在这里插入图片描述

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 继承的深入讨论/细节问题

子类继承了所有的属性和方法，只是私有的属性不能直接访问，需要通过公共的方法去访问
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 = "段誉";
}

在这里插入图片描述

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的比较

在这里插入图片描述

5 面向对象编程-多态

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

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

5.2 多态的具体体现

方法的多态
重写和重载
在这里插入图片描述
重写体现的多态


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() 就是运行类型】
在这里插入图片描述

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)当调用对象属性时，没有动态绑定机制，哪里声明，那里使用

andyonlines

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
10 面对对象-中篇

1 包现在有两个程序员共同开发一个java项目,程序员xiaoming希望定义一个类取名 Dog ,程序员xiaoqiang也想定义一个类也叫 Dog。两个程序员为此还吵了起来,怎么办?1.1 包的三大作用区分相同名字的类当类很多时,可以很好的管理类控制访问范围1.2 打包命令打包基本语法package com.atguigu;说明: package 关键字,表示打包.co...
复制链接

扫一扫