本文详细介绍了Java的面向对象三大特性：封装、继承和多态。封装通过private关键字隐藏数据，使用构造方法和getter/setter方法进行访问。继承允许子类从父类继承属性和方法，子类可以重写父类的方法。多态则是同一行为的不同表现形式，通过父类引用调用子类对象的方法实现。文章还讨论了super和this关键字的用法，以及向上和向下转型的概念。
一. 封装
1.1 封装概述
面向对象编程语言是对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界无法直接操作和修改.封装可以被认为是一个保护屏障，防止该类的代码和数据被其他类随意访问。要访问该类的数据，必须通过指定的方式。适当的封装可以让代码更容易理解与维护，也加强了代码的安全性。
原则:
将属性隐藏起来，若需要访问某个属性，提供公共方法对其访问。
1.2 封装步骤
1.使用 private 关键字来修饰成员变量。
2.对需要访问的成员变量，提供对应的一对 getXxx 方法 、 setXxx 方法。
1.3 封装的操作 – private
1. private是一个权限修饰符，代表最小权限。
2. 可以修饰成员变量和成员方法。
3.被private修饰后的成员变量和成员方法，只在本类中才能访问。
private 数据类型 变量名；
public class Student {
private String name;
private int age;
public void setName(String n) {
name = n;
}
public String getName() {
return name;
}
public void setAge(String a) {
age = n;
}
public String getAge() {
return age;
}
}
1.4 封装优化1 – this关键字
在修改了 setXxx() 的形参变量名后，方法并没有给成员变量赋值！这是由于形参变量名与成员变量名重名，导致成员变量名被隐藏，方法中的变量名，无法访问到成员变量，从而赋值失败。所以，我们只能使用this关键字,来解决这个重名问题;
this的含义:this代表所在类的当前对象的引用（地址值），即对象自己的引用;
备注: 方法被哪个对象调用，方法中的this就代表那个对象,即谁在调用,this就代表谁
public class test{
public void test1(){
System.out.println(this);
}
}
public class testMain {
public static void main(String[] args) {
Test t = new Test();
System.out.println(t);
t.test1();
}
}
cn.gdmcmc.esi.lei.Test@66d3c617
cn.gdmcmc.esi.lei.Test@66d3c617
this使用格式:
this.成员变量名；
public class Student {
private String name;
private int age;
public void setName(String name) {
//name = n;
this.name = name
}
public String getName() {
return this.name;
}
public void setAge(String age) {
//age = n;
this.age = age
}
public String getAge() {
return this.age;
}
}
1.5 封装优化2 – 构造方法
当一个对象被创建时候，构造方法用来初始化该对象，给对象的成员变量赋初始值。
修饰符 构造方法名(参数列表){
// 方法体
}
public class Student {
private String name;
private int age;
// 无参数构造方法
public Student() {}
// 有参数构造方法
public Student(String name,int age) {
this.name = name;
this.age = age;
}
}
注意事项:
1.如果你不提供构造方法,系统会给出无惨构造方法
2.如果你提供了构造方法,系统将不再提供无惨构造方法,需要自己补上,否则会报错
3.构造方法是可以重载,既可以定义参数,也可以不定义参数
1.6 标准代码 – JavaBean
JavaBean 是 Java语言编写类的一种标准规范。符合 JavaBean 的类，要求类必须是具体的和公共的，并且具有无参数的构造方法，提供用来操作成员变量的 set 和 get 方法。
public class Student {
//成员变量
private String name;
private int age;
//构造方法
public Student() {}
public Student(String name,int age) {
this.name = name;
this.age = age;
}
//成员方法
publicvoid setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
publicvoid setAge(int age) {
this.age = age;
}
publicint getAge() {
return age;
}
}
测试类
public class TestStudent {
public static void main(String[] args) {
//无参构造使用
Student s= new Student();
s.setName("柳岩");
s.setAge(18);
System.out.println(s.getName()+"‐‐‐"+s.getAge());
//带参构造使用
Student s2= new Student("赵丽颖",18);
System.out.println(s2.getName()+"‐‐‐"+s2.getAge());
}
}
二. 继承
2.1 继承概述
Java中的继承是指在现有类的基础上定义一个新的类,现有类称为父类,新的类称为子类,子类会自动拥有父类的可继承的内容多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那一个类即可。其中，多个类可以称为子类，单独那一个类称为父类、超类（superclass）或者基类。
定义:
**继承：**就是子类继承父类的属性和行为，使得子类对象具有与父类相同的属性、相同的行为。子类可以 直接访问父类中的非私有的属性和行为。
好处:
1.提高代码的复用性。
2.类与类之间产生了关系，是多态的前提。
2.2 继承的格式
通过 extends 关键字，可以声明一个子类继承另外一个父类，定义格式如下：
class 父类 {
...
}
class 子类 extends 父类 {
...
}
1.父类
public class Person {
String name;
int age;
public void eat() {
System.out.println(name + "吃饭");
}
public void sleep() {
System.out.println(name + "睡觉");
}
}
2.子类
public class Coder extends Person {
// 敲代码
public void coding() {
System.out.println(name + "敲代码");
}
}
3.子类
public class Teacher extends Person {
public void teach() {
System.out.println(name + "上课");
}
}
4.测试类
public class Demo02 {
public static void main(String[] args) {
Coder c = new Coder();
c.name = "马化腾";
c.age = 45;
c.eat();
c.sleep();
c.coding();
System.out.println("‐‐‐‐‐‐‐‐‐‐‐");
Teacher t = new Teacher();
t.name = "马云";
t.age = 50;
t.eat();
t.sleep();
t.teach();
}
}
2.3 父类不可被继承的内容
并不是父类的所有内容都可以给子类继承的,以下2个内容不能被子类继承:
1.被private修饰的
2.构造方法不能继承
2.4 继承后的特点 – 成员变量
1.4.1 成员变量不重名
如果子类父类出现不重名的成员变量,这时访问是没有影响的
1.4.2 成员变量重名
如果子类父类中出现重名的成员变量，这时的访问是有影响的。
如果子类直接直接访问重名的成员变量,就是访问自己的;
子父类中出现了同名的成员变量时，在子类中需要访问父类中非私有成员变量时，需要使用 super 关键字，修饰父类成员变量，类似于之前学过的 this 。
super.父类成员变量名
class Fu1 {
// Fu中的成员变量。
int num = 5;
}
class Zi extends Fu {
// Zi中的成员变量
int num = 6;
public void show() {
int num = 1;
// 访问方法中的num
System.out.println("method num=" + num);
// 访问子类中的num
System.out.println("Zi num=" + this.num);
// 访问父类中的num
System.out.println("Fu num=" + super.num);
}
}演示结果：
method num=1
Zi num=6
Fu num=5
父类中的成员变量是非私有的，子类中可以直接访问。若父类中的成员变量私有了，子类是不能
直接访问的。通常编码时，我们遵循封装的原则，使用private修饰成员变量，那么如何访问父类的私有成员
变量呢？对！可以在父类中提供公共的getXxx方法和setXxx方法。
2.5 继承后的特点 – 成员方法
1.5.1 成员方法不重名
如果子类父类中出现不重名的成员方法，这时的调用是没有影响的。对象调用方法时，会先在子类中查找有没有对应的方法，若子类中存在就会执行子类中的方法，若子类中不存在就会执行父类中相应的方法。
1.5.2 成员方法重名 – 重写
如果子类父类中出现重名的成员方法，这时的访问是一种特殊情况，叫做方法重写 (Override)。
**方法重写 ：**子类中出现与父类一模一样的方法时（返回值类型，方法名和参数列表都相同），会出现覆盖效果，也称为重写或者复写。声明不变，重新实现。
class Fu {
public void show() {
System.out.println("Fu show");
}
}
class Zi extends Fu {
//子类重写了父类的show方法
public void show() {
System.out.println("Zi show");
}
}
public class ExtendsDemo05{
public static void main(String[] args) {
Zi z = new Zi();
// 子类中有show方法，只执行重写后的show方法
z.show(); // Zi show
}
}
备注: 这里重写时，用到super.父类成员方法，表示调用父类的成员方法。
注意事项:
1. 子类方法覆盖父类方法，必须要保证权限大于等于父类权限。
2. 子类方法覆盖父类方法，返回值类型、函数名和参数列表都要一模一样。
2.6 继承后的特点 – 构造方法
1. 构造方法的名字是与类名一致的。所以子类是无法继承父类构造方法的。
2. 构造方法的作用是初始化成员变量的。所以子类的初始化过程中，必须先执行父类的初始化动作。子类的构 造方法中默认有一个 super() ，表示调用父类的构造方法，父类成员变量初始化后，才可以给子类使用。
//父类
public class Test {
private String name;
private Integer age;
public Test(){
System.out.println("父类无参");
}
public Test(String name, Integer age) {
System.out.println("父类有参");
this.name = name;
this.age = age;
}
}
//子类
public class Test1 extends Test{
private String sex;
public Test1() {
System.out.println("子类无参");
}
public Test1(String sex) {
System.out.println("子类有参");
this.sex = sex;
}
}
//测试类
public class testMain {
public static void main(String[] args) {
Test1 test1 = new Test1();
System.out.println("-----------");
Test1 test2 = new Test1("男");
}
}
//结果
父类无参
子类无参
-----------
父类无参
子类有参
2.7 super 和 this
父类空间优先于子类对象产生:
在每次创建子类对象时，先初始化父类空间，再创建其子类对象本身。目的在于子类对象中包含了其对应的父类空间，便可以包含其父类的成员，如果父类成员非private修饰，则子类可以随意使用父类成员。代码体现在子类的构 造方法调用时，一定先调用父类的构造方法。
2.7.1 super和this的含义
**super ：**代表父类的存储空间标识(可以理解父亲的引用)。
**this ：**代表当前对象的引用(谁调用就代表谁).
2.7.2 super和this的用法
1. 访问成员
this.成员变量 ‐‐ 本类的
super.成员变量 ‐‐ 父类的
this.成员方法名() ‐‐ 本类的
super.成员方法名() ‐‐ 父类的
2.访问构造方法
this(...) ‐‐ 本类的构造方法
super(...) ‐‐ 父类的构造方法
注意: 子类的每个构造方法中均有默认的super()，调用父类的空参构造。手动调用父类构造会覆盖默认的super()。 super() 和 this() 都必须是在构造方法的第一行，所以不能同时出现。
2.8 继承的特点
-
Java只支持单继承，不支持多继承。 (一个类只有一个父类)
-
一个类可以有多个子类。 (多个不同的子类继承一个父类)
-
Java支持多层继承(继承体系)。(a 继承 b,b 继承 c)
顶层父类是Object类。所有的类默认继承Object，作为父类。
-
子类和父类是一种相对的概念。
三. 多态
3.1 概述
多态是继封装、继承之后，面向对象的第三大特性。
多态： 是指同一行为，具有多个不同表现形式.
3.2 多态的体现
格式:
父类类型 变量名 = new 子类对象;
变量名.方法名();
当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，执行的是子类重写后方法。
3.3 多态的好处
实际开发的过程中，父类类型作为方法形式参数，传递子类对象给方法，进行方法的调用，更能体现出多态的扩展性与便利。
//父类
public abstract class Animal {
public abstract void eat();
}
//子类
class Cat extends Animal{
public void eat(){
System.out.println("吃鱼");
}
}
class Dog extends Animal{
public void eat(){
System.out.println("吃肉");
}
}
//测试类
public class test{
public static void main(String[] args) {
// 多态形式，创建对象
Cat c = new Cat();
Dog d = new Dog();
// 调用showCatEat
showCatEat(c);
// 调用showDogEat
showDogEat(d);
/*
以上两个方法, 均可以被showAnimalEat(Animal a)方法所替代
而执行效果一致
*/
showAnimalEat(c);
showAnimalEat(d);
}
public static void showCatEat (Cat c){
c.eat();
}
public static void showDogEat (Dog d){
d.eat();
}
public static void showAnimalEat (Animal a){
a.eat();
}
}
由于多态特性的支持，showAnimalEat方法的Animal类型，是Cat和Dog的父类类型，父类类型接收子类对象，当然可以把Cat对象和Dog对象，传递给方法。
当eat方法执行时，多态规定，执行的是子类重写的方法，那么效果自然与showCatEat、showDogEat方法一致，所以showAnimalEat完全可以替代以上两方法。
不仅仅是替代，在扩展性方面，无论之后再多的子类出现，我们都不需要编写showXxxEat方法了，直接使用
showAnimalEat都可以完成。
所以，多态的好处，体现再,可以使程序编写的更简单,并有良好的拓展;
3.4 引用数据类型转换
1.自动强转:范围小的赋值给范围大的,自动完成:double d = 5;
2.强制转换:范围大的赋值给范围小的,强制转换:int i = (int) 3.14;
3.4.1 向上转型
**向上转型：**多态本身是子类类型向父类类型向上转换的过程，这个过程是默认的。
当父类引用指向一个子类对象时，便是向上转型。
父类类型 变量名 = new 子类类型();
如：Animal a = new Cat();
3.4.2 向下转型
**向下转型：**父类类型向子类类型向下转换的过程，这个过程是强制的。
一个已经向上转型的子类对象，将父类引用转为子类引用，可以使用强制类型转换的格式，便是向下转 型。
子类类型 变量名 = (子类类型) 父类变量名;
如:Cat c =(Cat) a;
3.5 为何要转型
当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误。也就是说，不能调用子类拥有，而父类没有的方法。编译都错误，更别说运行了。这也是多态给我们带来的一点"小麻烦"。所以，想要调用子类特有的方法，必须做向下转型。
//父类
abstract class Animal {
abstract void eat();
}
//子类
class Cat extends Animal {
public void eat() {
System.out.println("吃鱼");
}
public void catchMouse() {
System.out.println("抓老鼠");
}
}
class Dog extends Animal {
public void eat() {
System.out.println("吃鱼");
}
public void watchHousu() {
System.out.println("看家");
}
}
//测试类
public class Test {
public static void main(String[] args) {
// 向上转型
Animal a = new Cat();
a.eat(); // 调用的是 Cat 的 eat
// 向下转型
Cat c = (Cat)a;
c.catchMouse(); // 调用的是 Cat 的 catchMouse
}
}
3.6 转型的异常
public class Test {
public static void main(String[] args) {
// 向上转型
Animal a = new Cat();
a.eat(); // 调用的是 Cat 的 eat
// 向下转型
Dog d = (Dog)a;
d.watchHouse(); // 调用的是 Dog 的 watchHouse 【运行报错】
}
}
这段代码可以通过编译，但是运行时，却报出了 ClassCastException ，类型转换异常！这是因为，明明创建了
Cat类型对象，运行时，当然不能转换成Dog对象的。这两个类型并没有任何继承关系，不符合类型转换的定义。
为了避免ClassCastException的发生，Java提供了 instanceof 关键字，给引用变量做类
变量名 instanceof 数据类型
如果变量数据该数据类型,返回true
如果变量不属于该数据类型,返回false
校验案例:
public class Test{
public static void main(String[] args){
//向上转型
Animal a = new Cat();
a.eat();
// 向下转型
if (a instanceof Cat){
Cat c = (Cat)a;
c.catchMouse(); // 调用的是 Cat 的 catchMouse
} else if (a instanceof Dog){
Dog d = (Dog)a;
d.watchHouse(); // 调用的是 Dog 的 watchHouse
}
}
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
