|
目录
文章目录
前言
一、封装
1.封装概述
2.封装原则
3.封装好处
4.封装中两个关键字
4.1private关键字
4.2this关键字
5.代码演示
二、继承
1.继承的概念
2.实现继承的格式
?3.继承的好处和弊端
3.1继承的好处
3.2继承的弊端
4.继承中的成员访问特点
4.1继承中变量的访问特点
4.2继承中成员方法的访问特点
4.3super与this的区别
?5.方法重写
5.1方法重写概念
5.2应用场景
5.3Override注解
?5.4方法重写的注意事项
5.5方法重写与重载的区别
6.继承的注意事项
三、 多态
1.多态的概述
1.1什么是多态
1.2多态的前提
?2.多态的好处和弊端
2.1多态的好处
2.2多态的弊端
3.多态中的成员访问特点
?4多态中的转型
4.1向上转型
4.2向下转型
前言
这是萌新自己总结的关于java面向对象的三大特征，封装，继承，多态。有错误请包涵。
一、封装
1.封装概述
是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界是无法直接操作的。
2.封装原则
将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问。
成员变量private，提供对应的getXxx()/setXxx()方法。
3.封装好处
通过方法来控制成员变量的操作，提高了代码的安全性 把代码用方法进行封装，提高了代码的复用性。
4.封装中两个关键字
4.1private关键字
因为封装最主要是将类的某些信息隐藏在类内部，不允许外部程序直接访问，所有private关键字是看见封装就要想到的。
private是一个修饰符，可以用来修饰成员（成员变量，成员方法）。
被private修饰的成员，只能在本类进行访问，针对private修饰的成员变量，如果需要被其他类使用，提供相应的操作：
4.2this关键字
this修饰的变量用于指代成员变量，其主要作用是（区分局部变量和成员变量的重名问题）
?this代表当前调用方法的引用，哪个对象调用的方法，this就代表哪一个对象
5.代码演示
public class Student {
//成员变量
private String name;//用private修饰，外部不能直接访问
private int age;
//无参构造方法
public Student(){
}
//有参构造方法
public Student(String name,int age){//this区分成员变量与形参重名问题
this.name=name;
this.age=age;
}
//成员方法
public void setName(String name){//根据提供的get(),set()方法，外部可以访问
this.name=name;
}
public String getName(){
return name;
}
public void setAge(int age){
this.age=age;
}
public int getAge(){
return age;
}
public void show(){
System.out.println(getName()+" "+getAge());
}
}
//测试类
public class Studentdemo {
public static void main(String[] args) {
Student s=new Student();
s.setName("林青霞");
s.setAge(30);
s.show();
Student s1=new Student("张曼玉",20);
s1.show();
}
}
二、继承
1.继承的概念
继承是面向对象三大特征之一，可以使得子类具有父类的属性和方法，还可以在子类中重新定义，以及追加属性和方法
2.实现继承的格式
class Dog extends Animal { }//狗继承动物
?3.继承的好处和弊端
3.1继承的好处
3.2继承的弊端
继承让类与类之间产生了关系，类的耦合性增强了，当父类发生变化时子类实现也不得不跟着变化，削弱了子类的独立性
4.继承中的成员访问特点
4.1继承中变量的访问特点
在子类方法中访问一个变量，采用的是就近原则。
-
子类局部范围找 -
子类成员范围找 -
父类成员范围找 -
如果都没有就报错(不考虑父亲的父亲…)
class Fu {
int num = 10;
}
class Zi extends Fu{
int num = 20;
public void show(){
int num = 30;
System.out.println(num);
}
}
public class Demo1 {
public static void main(String[] args) {
Zi z = new Zi();
z.show(); // 输出show方法中的局部变量num=30
}
}
4.2继承中成员方法的访问特点
通过子类对象访问一个方法
-
子类成员范围找 -
父类成员范围找 -
如果都没有就报错(不考虑父亲的父亲…)
4.3super与this的区别
-
this&super关键字：
-
this和super的使用分别
-
成员变量：
-
this.成员变量 - 访问本类成员变量 -
super.成员变量 - 访问父类成员变量
-
成员方法：
-
this.成员方法 - 访问本类成员方法 -
super.成员方法 - 访问父类成员方法
-
构造方法：
-
this(…) - 访问本类构造方法 -
super(…) - 访问父类构造方法
?5.方法重写
5.1方法重写概念
子类出现了和父类中一模一样的方法声明（方法名一样，参数列表也必须一样）
5.2应用场景
当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容
5.3Override注解
用来检测当前的方法，是否是重写的方法，起到【校验】的作用
@Override
private void show() {
System.out.println("Zi中show()方法被调用");
}
?5.4方法重写的注意事项
-
私有方法不能被重写(父类私有成员子类是不能继承的) -
子类方法访问权限不能更低(public > 默认 > 私有)
public class Fu {
private void show() {
System.out.println("Fu中show()方法被调用");
}
void method() {
System.out.println("Fu中method()方法被调用");
}
}
public class Zi extends Fu {
/* 编译【出错】，子类不能重写父类私有的方法*/
@Override
private void show() {
System.out.println("Zi中show()方法被调用");
}
/* 编译【出错】，子类重写父类方法的时候，访问权限需要大于等于父类 */
@Override
private void method() {
System.out.println("Zi中method()方法被调用");
}
/* 编译【通过】，子类重写父类方法的时候，访问权限需要大于等于父类 */
@Override
public void method() {
System.out.println("Zi中method()方法被调用");
}
}
5.5方法重写与重载的区别
?1.重写：方法名一样，参数列表也必须一样
? ? 重载：方法名一样，多个方法的参数不相同，类型不同或者数量不同
2.位置：重写在继承类或者实现类
? ? ? ? ? ? ? 重载在同一个类中
6.继承的注意事项
-
Java中类只支持单继承，不支持多继承
-
Java中类支持多层继承
public class Granddad {
public void drink() {
System.out.println("爷爷爱喝酒");
}
}
public class Father extends Granddad {
public void smoke() {
System.out.println("爸爸爱抽烟");
}
}
public class Mother {
public void dance() {
System.out.println("妈妈爱跳舞");
}
}
public class Son extends Father {
// 此时，Son类中就同时拥有drink方法以及smoke方法
}
三、 多态
1.多态的概述
1.1什么是多态
同一个对象，在不同时刻表现出来的不同形态
1.2多态的前提
-
-
要有继承或实现关系 -
要有方法的重写 -
要有父类引用指向子类对象
?2.多态的好处和弊端
2.1多态的好处
提高程序的扩展性。定义方法时候，使用父类型作为参数，在使用的时候，使用具体的子类型参与操作
2.2多态的弊端
不能使用子类的特有成员
3.多态中的成员访问特点
成员访问特点
-
成员变量 编译看父类，运行看父类 -
成员方法 编译看父类，运行看子类
//动物类
public class Animal {
public int age = 40;
public void eat() {
System.out.println("动物吃东西");
}
}
//猫类
public class Cat extends Animal {
public int age = 20;
public int weight = 10;
@Override
public void eat() {
System.out.println("猫吃鱼");
}
public void playGame() {
System.out.println("猫捉迷藏");
}
}
//测试类
public class AnimalDemo {
public static void main(String[] args) {
//有父类引用指向子类对象
Animal a = new Cat();
System.out.println(a.age);
// System.out.println(a.weight);
a.eat();
// a.playGame();
}
?4多态中的转型
4.1向上转型
父类引用指向子类对象就是向上转型
4.2向下转型
格式：子类型 对象名 = (子类型)父类引用;
结合上面代码演示
public class AnimalDemo {
public static void main(String[] args) {
//多态
//向上转型
Animal a = new Cat();
a.eat();
// a.playGame();
//向下转型
Cat c = (Cat)a;
c.eat();
c.playGame();
}
}
|