文章目录

• 前言
• 再续上篇
• 继承
• 重写与重载
• 封装
• 接口
• 抽象类
• 枚举

前言

郑重声明！！！！

本人大一菜鸡，不要以为我多厉害，我是IT小白，此系列只是笔记，只是我巩固知识的

看一遍，想一遍，再写一遍让别人理解，我就会更加的深入理解

当然，如果有什么理解上的错误，请帮我指出，完善我的学习！谢谢~

再续上篇

继承，封装，重写

继承

好的，我们造的妹子此时已经和我们结了婚，生了娃！（喝彩 O(∩_∩)O哈哈~ ）

继承就是我们的孩子，有我们造的妹子的特性，比如说：孩子长得像他妈妈啦，性格像她妈妈啦之类的

虽然在Java中，被继承的类叫做父类，但是我们也是可以这么理解的~

后面我就叫做母类了，emmm原谅我，我只是觉得这样更好听一点

当然，Java中，类的继承只支持单继承

上篇的妹子类，我就不写了，占字数，想看可以去看看——妹子类

public class Ex4_22 {
public static void main(String[] args) {
Child ch = new Child();
ch.setAge(10);
int age = ch.getAge();
System.out.println("孩子的年龄是："+age);
System.out.println("孩子会撒娇");
ch.coqutry();
}
}
class Child extends Girl{
/*
孩子继承了妈妈的特性
*/
}
/*
运行结果：
孩子的年龄是：10
孩子会撒娇
哥哥不要这样啦，人家害怕啦~~~
*/

重写与重载

1. 重写

就是我们的孩子虽然已经继承了妈妈的东西，但是有些东西总不能是完全一样的

这个时候就要重写操作，可以将母类的东西改变，延伸

当然，我们的重写必须是跟母类的形参和返回值是相同的、、、

p
20000
ublic class Ex4_22 {
public static void main(String[] args) {
Child ch = new Child();
ch.setAge(10);
int age = ch.getAge();
System.out.println("孩子的年龄是："+age);
System.out.println("孩子会撒娇");
ch.coqutry();
}
}
class Child extends Girl{
public void coqutry(){
System.out.println("粑粑，我好爱你哦~~~");
}
}
/*
运行结果：
孩子的年龄是：10
孩子会撒娇
粑粑，我好爱你哦~~~
*/

1. 重载
   重载是构造方法的重载，之前说过就不说了

封装

还记不记得我之前说过的规范

一般将属性设置为private，私有类型，无法被外界的访问

而对于这样的属性，我们一般需要对每个属性设置两个方法，
一个是getXxx()， 一个是setXxx()，用于对属性初始化和调用
这个过程就是封装

class Girl{
private int age;  //这个是年龄属性
private String name;  //这个是姓名属性
public void setName(String name){
/*
设置名字
参数：name 名字
*/
this.name = name;
}
String getName(){
/*
获取名字
*/
return name;
}
public void setAge(int age){
/*
设置年龄
*/
this.age = age;
}
public int getAge(){
/*
获取年龄
*/
return age;
}
}

接口

接口使用interface关键词来定义

interface Text{
//定义一个接口
}

接口是抽象方法的结合，被类继承
接口支持多继承（可以继承爸爸妈妈爷爷奶奶很多人的特性）

接口没有构造方法，因此无法进行实例化对象操作，只有在被类继承后，才可以继承用到接口中的方法

接口被类继承需要用到implements关键词

public class Ex4_22 {
public static void main(String[] args) {
Text_1 te1 = new Text_1();
te1.eat();
}
}

interface Text_0 {
int a = 0;
public void eat();
}
class Text_1 implements Text_0 {
public void eat(){
System.out.println("00");
}

}
//运行结果：00

抽象类

抽象类并没有那么多属性可以去描绘一个完整的个体

public abstract class Ex4_22{
//定义一个抽象类
}

抽象类的方法也是抽象的，就是不具体的，就比如

我会说话，但是你只知道我会说话，而不知道我会说什么话，而这个会说话的方法就是抽象方法。

public abstract void print();//抽象方法，没有方法体，有abstract关键字做修饰

和接口不同的是，抽象类虽然无法实例化对象，但是抽象类是个类，有构造方法
所以抽象类一般在设计程序的时候就要考虑是否定义

而抽象类被继承后，继承抽象类的类需要将抽象类的抽象方法重写，使其具体化

public class Ex4_22 {
public static void main(String[] args) {
Text te = new Text();
te.print();
}
}
abstract class Ex4_2 {
//定义一个抽象类
public abstract void print();//抽象方法，没有方法体，有abstract关键字做修饰}
class Text extends Ex4_2{
public void print(){
System.out.println("Hello");
}
}
//运行结果：Hello

枚举

Java 枚举是一个特殊的类，一般表示一组常量

比如妹子的性别等

使用enum定义

enum Gender{
MAN, WOMAN;
}

public class Test{
// 执行输出结果
public static void main(String[] args){
Gender c1 = Gender.MAN;
System.out.println(c1);
}
}
//运行结果：MAN

可以使用switch语句来使用

enum Gender{
MAN, WOMAN;
}
public class Ex4_22 {
public static void main(String[] args) {
Color myVar = Gender.MAN;

switch(myVar) {
case :
System.out.println("男性");
break;
case WOMAN:
System.out.println("女性");
break;
}
}
}
//运行结果：男性

枚举可以在类内部定义

结语

时间不早了，xdm为了保护头发，早点睡觉吧~
保护头发，人人有责！

xdm冲冲冲，我先溜了