营口旅游网站建设,有没有设计网站在广州的,全国市场主体登记注册服务网,网站建设作业做一个简单的网站文章目录 面向对象进阶部分学习方法#xff1a;今日内容教学目标 第一章 复习回顾1.1 如何定义类1.2 如何通过类创建对象1.3 封装1.3.1 封装的步骤1.3.2 封装的步骤实现 1.4 构造方法1.4.1 构造方法的作用1.4.2 构造方法的格式1.4.3 构造方法的应用 1.5 this关键字的作用1.5.1… 文章目录 面向对象进阶部分学习方法今日内容教学目标 第一章 复习回顾1.1 如何定义类1.2 如何通过类创建对象1.3 封装1.3.1 封装的步骤1.3.2 封装的步骤实现 1.4 构造方法1.4.1 构造方法的作用1.4.2 构造方法的格式1.4.3 构造方法的应用 1.5 this关键字的作用1.5.1 this关键字的作用1.5.2 this关键字的应用1.5.2.1 用于普通的gettter与setter方法1.5.2.2 用于构造方法中 第二章 static关键字2.1 概述2.2 定义格式和使用2.2.1 静态变量及其访问2.2.2 实例变量及其访问2.2.3 静态方法及其访问2.2.4 实例方法及其访问 2.3 小结 第三章 继承3.1 概述3.1.1 引入3.1.2 继承的含义3.1.3 继承的好处 3.2 继承的格式3.3 继承案例3.3.1 案例3.3.2 案例图解分析3.3.3 案例代码实现3.3.4 小结 3.4 子类不能继承的内容3.4.1 引入3.4.1 演示代码 3.5 继承后的特点—成员变量3.5.1 成员变量不重名3.5.2 成员变量重名3.5.3 super访问父类成员变量 3.6 继承后的特点—成员方法3.6.1 成员方法不重名3.6.2 成员方法重名 3.7 方法重写3.7.1 概念3.7.2 使用场景与案例3.7.2 Override重写注解3.7.3 注意事项 3.8 继承后的特点—构造方法3.8.1 引入3.8.2 案例演示3.8.3 小结 3.9 super(...)和this(...)3.9.1 引入3.9.2 super和this的用法格式3.9.3 super(....)用法演示3.9.4 super(...)案例图解3.9.5 this(...)用法演示3.9.6 小结 3.10 继承的特点4. 关于今天知识的小结 面向对象进阶部分学习方法
特点
逻辑性没有那么强但是概念会比较多。
记忆部分重要的概念理解课堂上讲解的需要大家掌握的概念多多练习代码。
今日内容
复习回顾static关键字继承
教学目标 能够掌握static关键字修饰的变量调用方式 能够掌握static关键字修饰的方法调用方式 知道静态代码块的格式和应用场景 能够写出类的继承格式 能够说出继承的特点 能够区分this和super的作用 能够说出方法重写的概念 能够说出方法重写的注意事项
第一章 复习回顾
1.1 如何定义类
类的定义格式如下:
修饰符 class 类名 {// 1.成员变量属性// 2.成员方法 (行为) // 3.构造方法 初始化类的对象数据的
}例如:
public class Student {// 1.成员变量public String name ;public char sex ; // 男 女public int age;
}1.2 如何通过类创建对象
类名 对象名称 new 类名();例如:
Student stu new Student();1.3 封装
1.3.1 封装的步骤
1.使用 private 关键字来修饰成员变量。
2.使用public修饰getter和setter方法。
1.3.2 封装的步骤实现
private修饰成员变量
public class Student {private String name;private int age;
}public修饰getter和setter方法
public class Student {private String name;private int age;public void setName(String n) {name n;}public String getName() {return name;}public void setAge(int a) {if (a 0 a 200) {age a;} else {System.out.println(年龄非法);}}public int getAge() {return age;}
}1.4 构造方法
1.4.1 构造方法的作用
在创建对象的时候给成员变量进行初始化。
初始化即赋值的意思。
1.4.2 构造方法的格式
修饰符 类名(形参列表) {// 构造体代码执行代码
}1.4.3 构造方法的应用
首先定义一个学生类代码如下
public class Student {// 1.成员变量public String name;public int age;// 2.构造方法public Student() {System.out.println(无参数构造方法被调用)}
}接下来通过调用构造方法得到两个学生对象。
public class CreateStu02 {public static void main(String[] args) {// 创建一个学生对象// 类名 变量名称 new 类名();Student s1 new Student();// 使用对象访问成员变量赋值s1.name 张三;s1.age 20 ;// 使用对象访问成员变量 输出值System.out.println(s1.name);System.out.println(s1.age); Student s2 new Student();// 使用对象访问成员变量 赋值s2.name 李四;s2.age 18 ;System.out.println(s2.name);System.out.println(s2.age);}
}1.5 this关键字的作用
1.5.1 this关键字的作用
this代表所在类的当前对象的引用地址值即代表当前对象。
1.5.2 this关键字的应用
1.5.2.1 用于普通的gettter与setter方法
this出现在实例方法中谁调用这个方法哪个对象调用这个方法this就代表谁this就代表哪个对象。
public class Student {private String name;private int age;public void setName(String name) {this.name name;}public String getName() {return name;}public void setAge(int age) {if (age 0 age 200) {this.age age;} else {System.out.println(年龄非法);}}public int getAge() {return age;}
}1.5.2.2 用于构造方法中
this出现在构造方法中代表构造方法正在初始化的那个对象。
public class Student {private String name;private int age;// 无参数构造方法public Student() {} // 有参数构造方法public Student(String name,int age) {this.name name;this.age age; }
}第二章 static关键字
2.1 概述
以前我们定义过如下类
public class Student {// 成员变量public String name;public char sex; // 男 女public int age;// 无参数构造方法public Student() {}// 有参数构造方法public Student(String a) {}
}我们已经知道面向对象中存在类和对象的概念我们在类中定义了一些成员变量例如name,age,sex ,结果发现这些成员变量每个对象都存在因为每个对象都可以访问。
而像name ,age , sex确实是每个学生对象都应该有的属性应该属于每个对象。
所以Java中成员变量和方法等是存在所属性的Java是通过static关键字来区分的。static关键字在Java开发非常的重要对于理解面向对象非常关键。
关于 static 关键字的使用它可以用来修饰的成员变量和成员方法被static修饰的成员是属于类的是放在静态区中没有static修饰的成员变量和方法则是属于对象的。我们上面案例中的成员变量都是没有static修饰的所以属于每个对象。
2.2 定义格式和使用
static是静态的意思。 static可以修饰成员变量或者修饰方法。
2.2.1 静态变量及其访问
有static修饰成员变量说明这个成员变量是属于类的这个成员变量称为类变量或者静态成员变量。 直接用 类名访问即可。因为类只有一个所以静态成员变量在内存区域中也只存在一份。所有的对象都可以共享这个变量。
如何使用呢
例如现在我们需要定义传智全部的学生类那么这些学生类的对象的学校属性应该都是“传智”这个时候我们可以把这个属性定义成static修饰的静态成员变量。
定义格式
修饰符 static 数据类型 变量名 初始值 举例
public class Student {public static String schoolName 尚硅谷教育 // 属于类只有一份。// .....
}静态成员变量的访问:
格式类名.静态变量
public static void main(String[] args){System.out.println(Student.schoolName); // 传智播客Student.schoolName 尚硅谷程序员;System.out.println(Student.schoolName); // 黑马程序员
}2.2.2 实例变量及其访问
无static修饰的成员变量属于每个对象的 这个成员变量叫实例变量之前我们写成员变量就是实例成员变量。
需要注意的是实例成员变量属于每个对象必须创建类的对象才可以访问。
格式对象.实例成员变量
2.2.3 静态方法及其访问
有static修饰成员方法说明这个成员方法是属于类的这个成员方法称为类方法或者静态方法**。 直接用 类名访问即可。因为类只有一个所以静态方法在内存区域中也只存在一份。所有的对象都可以共享这个方法。
与静态成员变量一样静态方法也是直接通过类名.方法名称即可访问。
举例
public class Student{public static String schoolName 尚硅谷 // 属于类只有一份。// .....public static void study(){System.out.println(我们都在尚硅谷学习); }
}静态成员变量的访问:
格式类名.静态方法
public static void main(String[] args){Student.study();
}2.2.4 实例方法及其访问
无static修饰的成员方法属于每个对象的这个成员方法也叫做实例方法。
需要注意的是实例方法是属于每个对象必须创建类的对象才可以访问。
格式对象.实例方法
示例
public class Student {// 实例变量private String name ;// 2.方法行为// 无 static修饰实例方法。属于每个对象必须创建对象调用public void run(){System.out.println(学生可以跑步);}// 无 static修饰实例方法public void sleep(){System.out.println(学生睡觉);}public static void study(){}
}public static void main(String[] args){// 创建对象 Student stu new Student ;stu.name 徐干;// Student.sleep();// 报错必须用对象访问。stu.sleep();stu.run();
}2.3 小结
1.当 static 修饰成员变量或者成员方法时该变量称为静态变量该方法称为静态方法。该类的每个对象都共享同一个类的静态变量和静态方法。任何对象都可以更改该静态变量的值或者访问静态方法。但是不推荐这种方式去访问。因为静态变量或者静态方法直接通过类名访问即可完全没有必要用对象去访问。
2.无static修饰的成员变量或者成员方法称为实例变量实例方法实例变量和实例方法必须创建类的对象然后通过对象来访问。
3.static修饰的成员属于类会存储在静态区是随着类的加载而加载的且只加载一次所以只有一份节省内存。存储于一块固定的内存区域静态区所以可以直接被类名调用。它优先于对象存在所以可以被所有对象共享。
4.无static修饰的成员是属于对象对象有多少个他们就会出现多少份。所以必须由对象调用。
第三章 继承
3.1 概述
3.1.1 引入
假如我们要定义如下类: 学生类,老师类和工人类分析如下。 学生类 属性:姓名,年龄 行为:吃饭,睡觉 老师类 属性:姓名,年龄薪水 行为:吃饭,睡觉教书 班主任 属性:姓名,年龄薪水 行为:吃饭,睡觉管理
如果我们定义了这三个类去开发一个系统那么这三个类中就存在大量重复的信息属性:姓名年龄。行为吃饭睡觉。这样就导致了相同代码大量重复代码显得很臃肿和冗余那么如何解决呢
假如多个类中存在相同属性和行为时我们可以将这些内容抽取到单独一个类中那么多个类无需再定义这些属性和行为只要继承那一个类即可。如图所示
其中多个类可以称为子类单独被继承的那一个类称为父类、超类superclass或者基类。
3.1.2 继承的含义
继承描述的是事物之间的所属关系这种关系是is-a 的关系。例如兔子属于食草动物食草动物属于动物。可见父类更通用子类更具体。我们通过继承可以使多种事物之间形成一种关系体系。
继承就是子类继承父类的属性和行为使得子类对象可以直接具有与父类相同的属性、相同的行为。子类可以直接访问父类中的非私有的属性和行为。
3.1.3 继承的好处
提高代码的复用性减少代码冗余相同代码重复利用。使类与类之间产生了关系。
3.2 继承的格式
通过 extends 关键字可以声明一个子类继承另外一个父类定义格式如下
class 父类 {...
}class 子类 extends 父类 {...
}需要注意Java是单继承的一个类只能继承一个直接父类跟现实世界很像但是Java中的子类是更加强大的。
3.3 继承案例
3.3.1 案例
请使用继承定义以下类:
学生类 属性:姓名,年龄 行为:吃饭,睡觉老师类 属性:姓名,年龄薪水 行为:吃饭,睡觉教书班主任 属性:姓名,年龄薪水 行为:吃饭,睡觉管理
3.3.2 案例图解分析
老师类学生类还有班主任类实际上都是属于人类的我们可以定义一个人类把他们相同的属性和行为都定义在人类中然后继承人类即可子类特有的属性和行为就定义在子类中了。
如下图所示。 3.3.3 案例代码实现
1.父类Human类
public class Human {// 合理隐藏private String name ;private int age ;// 合理暴露public String getName() {return name;}public void setName(String name) {this.name name;}public int getAge() {return age;}public void setAge(int age) {this.age age;}
}2.子类Teacher类
public class Teacher extends Human {// 工资private double salary ;// 特有方法public void teach(){System.out.println(老师在认真教技术)}public double getSalary() {return salary;}public void setSalary(double salary) {this.salary salary;}
}3.子类Student类
public class Student extends Human{}4.子类BanZhuren类
public class Teacher extends Human {// 工资private double salary ;// 特有方法public void admin(){System.out.println(班主任强调纪律问题)}public double getSalary() {return salary;}public void setSalary(double salary) {this.salary salary;}
}5.测试类
public class Test {public static void main(String[] args) {Teacher dlei new Teacher();dlei.setName(播仔);dlei.setAge(31);dlei.setSalary(1000.99);System.out.println(dlei.getName());System.out.println(dlei.getAge());System.out.println(dlei.getSalary());dlei.teach();BanZhuRen linTao new BanZhuRen();linTao.setName(灵涛);linTao.setAge(28);linTao.setSalary(1000.99);System.out.println(linTao.getName());System.out.println(linTao.getAge());System.out.println(linTao.getSalary());linTao.admin();Student xugan new Student();xugan.setName(播仔);xugan.setAge(31);//xugan.setSalary(1000.99); // xugan没有薪水属性报错System.out.println(xugan.getName());System.out.println(xugan.getAge());}
}3.3.4 小结
1.继承实际上是子类相同的属性和行为可以定义在父类中子类特有的属性和行为由自己定义这样就实现了相同属性和行为的重复利用从而提高了代码复用。
2.子类继承父类就可以直接得到父类的成员变量和方法。是否可以继承所有成分呢请看下节
3.4 子类不能继承的内容
3.4.1 引入
并不是父类的所有内容都可以给子类继承的
子类不能继承父类的构造方法。
值得注意的是子类可以继承父类的私有成员成员变量方法只是子类无法直接访问而已可以通过getter/setter方法访问父类的private成员变量。
3.4.1 演示代码
public class Demo03 {public static void main(String[] args) {Zi z new Zi();System.out.println(z.num1);
// System.out.println(z.num2); // 私有的子类无法使用// 通过getter/setter方法访问父类的private成员变量System.out.println(z.getNum2());z.show1();// z.show2(); // 私有的子类无法使用}
}class Fu {public int num1 10;private int num2 20;public void show1() {System.out.println(show1);}private void show2() {System.out.println(show2);}public int getNum2() {return num2;}public void setNum2(int num2) {this.num2 num2;}
}class Zi extends Fu {
}3.5 继承后的特点—成员变量
当类之间产生了继承关系后其中各类中的成员变量又产生了哪些影响呢
3.5.1 成员变量不重名
如果子类父类中出现不重名的成员变量这时的访问是没有影响的。代码如下
class Fu {// Fu中的成员变量int num 5;
}
class Zi extends Fu {// Zi中的成员变量int num2 6;// Zi中的成员方法public void show() {// 访问父类中的numSystem.out.println(Fu numnum); // 继承而来所以直接访问。// 访问子类中的num2System.out.println(Zi num2num2);}
}
class Demo04 {public static void main(String[] args) {// 创建子类对象Zi z new Zi(); // 调用子类中的show方法z.show(); }
}演示结果
Fu num 5
Zi num2 63.5.2 成员变量重名
如果子类父类中出现重名的成员变量这时的访问是有影响的。代码如下
class Fu1 {// Fu中的成员变量。int num 5;
}
class Zi1 extends Fu1 {// Zi中的成员变量int num 6;public void show() {// 访问父类中的numSystem.out.println(Fu num num);// 访问子类中的numSystem.out.println(Zi num num);}
}
class Demo04 {public static void main(String[] args) {// 创建子类对象Zi1 z new Zi1(); // 调用子类中的show方法z1.show(); }
}
演示结果
Fu num 6
Zi num 6子父类中出现了同名的成员变量时子类会优先访问自己对象中的成员变量。如果此时想访问父类成员变量如何解决呢我们可以使用super关键字。
3.5.3 super访问父类成员变量
子父类中出现了同名的成员变量时在子类中需要访问父类中非私有成员变量时需要使用super 关键字修饰父类成员变量类似于之前学过的 this 。
需要注意的是super代表的是父类对象的引用this代表的是当前对象的引用。
使用格式
super.父类成员变量名子类方法需要修改代码如下
class Fu {// Fu中的成员变量。int num 5;
}class Zi extends Fu {// Zi中的成员变量int num 6;public void show() {int num 1;// 访问方法中的numSystem.out.println(method num num);// 访问子类中的numSystem.out.println(Zi num this.num);// 访问父类中的numSystem.out.println(Fu num super.num);}
}class Demo04 {public static void main(String[] args) {// 创建子类对象Zi1 z new Zi1(); // 调用子类中的show方法z1.show(); }
}演示结果
method num1
Zi num6
Fu num5小贴士Fu 类中的成员变量是非私有的子类中可以直接访问。若Fu 类中的成员变量私有了子类是不能直接访问的。通常编码时我们遵循封装的原则使用private修饰成员变量那么如何访问父类的私有成员变量呢对可以在父类中提供公共的getXxx方法和setXxx方法。 3.6 继承后的特点—成员方法
当类之间产生了关系其中各类中的成员方法又产生了哪些影响呢
3.6.1 成员方法不重名
如果子类父类中出现不重名的成员方法这时的调用是没有影响的。对象调用方法时会先在子类中查找有没有对应的方法若子类中存在就会执行子类中的方法若子类中不存在就会执行父类中相应的方法。代码如下
class Fu {public void show() {System.out.println(Fu类中的show方法执行);}
}
class Zi extends Fu {public void show2() {System.out.println(Zi类中的show2方法执行);}
}
public class Demo05 {public static void main(String[] args) {Zi z new Zi();//子类中没有show方法但是可以找到父类方法去执行z.show(); z.show2();}
}3.6.2 成员方法重名
如果子类父类中出现重名的成员方法则创建子类对象调用该方法的时候子类对象会优先调用自己的方法。
代码如下
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}
}3.7 方法重写
3.7.1 概念
方法重写 子类中出现与父类一模一样的方法时返回值类型方法名和参数列表都相同会出现覆盖效果也称为重写或者复写。声明不变重新实现。
3.7.2 使用场景与案例
发生在子父类之间的关系。 子类继承了父类的方法但是子类觉得父类的这方法不足以满足自己的需求子类重新写了一个与父类同名的方法以便覆盖父类的该方 法。
例如我们定义了一个动物类代码如下
public class Animal {public void run(){System.out.println(动物跑的很快);}public void cry(){System.out.println(动物都可以叫~~~);}
}然后定义一个猫类猫可能认为父类cry()方法不能满足自己的需求
代码如下
public class Cat extends Animal {public void cry(){System.out.println(我们一起学猫叫喵喵喵喵的非常好听);}
}public class Test {public static void main(String[] args) {// 创建子类对象Cat ddm new Cat()// 调用父类继承而来的方法ddm.run();// 调用子类重写的方法ddm.cry();}
}3.7.2 Override重写注解 Override:注解重写注解校验 这个注解标记的方法就说明这个方法必须是重写父类的方法否则编译阶段报错。 建议重写都加上这个注解一方面可以提高代码的可读性一方面可以防止重写出错 加上后的子类代码形式如下 public class Cat extends Animal {// 声明不变重新实现// 方法名称与父类全部一样只是方法体中的功能重写写了Overridepublic void cry(){System.out.println(我们一起学猫叫喵喵喵喵的非常好听);}
}3.7.3 注意事项
方法重写是发生在子父类之间的关系。子类方法覆盖父类方法必须要保证权限大于等于父类权限。子类方法覆盖父类方法返回值类型、函数名和参数列表都要一模一样。
3.8 继承后的特点—构造方法
3.8.1 引入
当类之间产生了关系其中各类中的构造方法又产生了哪些影响呢 首先我们要回忆两个事情构造方法的定义格式和作用。
构造方法的名字是与类名一致的。所以子类是无法继承父类构造方法的。构造方法的作用是初始化对象成员变量数据的。所以子类的初始化过程中必须先执行父类的初始化动作。子类的构造方法中默认有一个super() 表示调用父类的构造方法父类成员变量初始化后才可以给子类使用。先有爸爸才能有儿子
继承后子类构方法器特点:子类所有构造方法的第一行都会默认先调用父类的无参构造方法
3.8.2 案例演示
按如下需求定义类:
人类 成员变量: 姓名,年龄 成员方法: 吃饭学生类 成员变量: 姓名,年龄,成绩 成员方法: 吃饭
代码如下
class Person {private String name;private int age;public Person() {System.out.println(父类无参);}// getter/setter省略
}class Student extends Person {private double score;public Student() {//super(); // 调用父类无参,默认就存在可以不写必须再第一行System.out.println(子类无参);}public Student(double score) {//super(); // 调用父类无参,默认就存在可以不写必须再第一行this.score score; System.out.println(子类有参);}}public class Demo07 {public static void main(String[] args) {Student s1 new Student();System.out.println(----------);Student s2 new Student(99.9);}
}输出结果
父类无参
子类无参
----------
父类无参
子类有参3.8.3 小结
子类构造方法执行的时候都会在第一行默认先调用父类无参数构造方法一次。子类构造方法的第一行都隐含了一个**super()**去调用父类无参数构造方法**super()**可以省略不写。
3.9 super(…)和this(…)
3.9.1 引入
请看上节中的如下案例
class Person {private String name;private int age;public Person() {System.out.println(父类无参);}// getter/setter省略
}class Student extends Person {private double score;public Student() {//super(); // 调用父类无参构造方法,默认就存在可以不写必须再第一行System.out.println(子类无参);}public Student(double score) {//super(); // 调用父类无参构造方法,默认就存在可以不写必须再第一行this.score score; System.out.println(子类有参);}// getter/setter省略
}public class Demo07 {public static void main(String[] args) {// 调用子类有参数构造方法Student s2 new Student(99.9);System.out.println(s2.getScore()); // 99.9System.out.println(s2.getName()); // 输出 nullSystem.out.println(s2.getAge()); // 输出 0}
}我们发现子类有参数构造方法只是初始化了自己对象中的成员变量score而父类中的成员变量name和age依然是没有数据的怎么解决这个问题呢我们可以借助与super(…)去调用父类构造方法以便初始化继承自父类对象的name和age.
3.9.2 super和this的用法格式
super和this完整的用法如下其中thissuper访问成员我们已经接触过了。
this.成员变量 -- 本类的
super.成员变量 -- 父类的this.成员方法名() -- 本类的
super.成员方法名() -- 父类的接下来我们使用调用构造方法格式
super(...) -- 调用父类的构造方法根据参数匹配确认
this(...) -- 调用本类的其他构造方法根据参数匹配确认3.9.3 super(…)用法演示
代码如下
class Person {private String name 凤姐;private int age 20;public Person() {System.out.println(父类无参);}public Person(String name , int age){this.name name ;this.age age ;}// getter/setter省略
}class Student extends Person {private double score 100;public Student() {//super(); // 调用父类无参构造方法,默认就存在可以不写必须再第一行System.out.println(子类无参);}public Student(String name int agedouble score) {super(name ,age);// 调用父类有参构造方法Person(String name , int age)初始化name和agethis.score score; System.out.println(子类有参);}// getter/setter省略
}public class Demo07 {public static void main(String[] args) {// 调用子类有参数构造方法Student s2 new Student(张三2099);System.out.println(s2.getScore()); // 99System.out.println(s2.getName()); // 输出 张三System.out.println(s2.getAge()); // 输出 20}
}注意
子类的每个构造方法中均有默认的super()调用父类的空参构造。手动调用父类构造会覆盖默认的super()。
super() 和 this() 都必须是在构造方法的第一行所以不能同时出现。
super(…)是根据参数去确定调用父类哪个构造方法的。
3.9.4 super(…)案例图解
父类空间优先于子类对象产生
在每次创建子类对象时先初始化父类空间再创建其子类对象本身。目的在于子类对象中包含了其对应的父类空间便可以包含其父类的成员如果父类成员非private修饰则子类可以随意使用父类成员。代码体现在子类的构造七调用时一定先调用父类的构造方法。理解图解如下 3.9.5 this(…)用法演示
this(…)
默认是去找本类中的其他构造方法根据参数来确定具体调用哪一个构造方法。为了借用其他构造方法的功能。
package com.itheima._08this和super调用构造方法;
/*** this(...):* 默认是去找本类中的其他构造方法根据参数来确定具体调用哪一个构造方法。* 为了借用其他构造方法的功能。**/
public class ThisDemo01 {public static void main(String[] args) {Student xuGan new Student();System.out.println(xuGan.getName()); // 输出:徐干System.out.println(xuGan.getAge());// 输出:21System.out.println(xuGan.getSex());// 输出 男}
}class Student{private String name ;private int age ;private char sex ;public Student() {// 很弱我的兄弟很牛逼啊我可以调用其他构造方法Student(String name, int age, char sex)this(徐干,21,男);}public Student(String name, int age, char sex) {this.name name ;this.age age ;this.sex sex ;}public String getName() {return name;}public void setName(String name) {this.name name;}public int getAge() {return age;}public void setAge(int age) {this.age age;}public char getSex() {return sex;}public void setSex(char sex) {this.sex sex;}
}3.9.6 小结 子类的每个构造方法中均有默认的super()调用父类的空参构造。手动调用父类构造会覆盖默认的super()。 super() 和 this() 都必须是在构造方法的第一行所以不能同时出现。 super(…)和this(…)是根据参数去确定调用父类哪个构造方法的。 super(…)可以调用父类构造方法初始化继承自父类的成员变量的数据。 this(…)可以调用本类中的其他构造方法。
3.10 继承的特点
Java只支持单继承不支持多继承。
// 一个类只能有一个父类不可以有多个父类。
class A {}
class B {}
class C1 extends A {} // ok
// class C2 extends A, B {} // error一个类可以有多个子类。
// A可以有多个子类
class A {}
class C1 extends A {}
class C2 extends A {}可以多层继承。
class A {}
class C1 extends A {}
class D extends C1 {}顶层父类是Object类。所有的类默认继承Object作为父类。 4. 关于今天知识的小结
会写一个继承结构下的标准Javabean即可
需求
猫属性姓名年龄颜色
狗属性姓名年龄颜色吼叫
分享书写技巧
1.在大脑中要区分谁是父谁是子
2.把共性写到父类中独有的东西写在子类中
3.开始编写标准Javabean从上往下写
4.在测试类中创建对象并赋值调用
代码示例
package com.itheima.test4;public class Animal {//姓名年龄颜色private String name;private int age;private String color;public Animal() {}public Animal(String name, int age, String color) {this.name name;this.age age;this.color color;}public String getName() {return name;}public void setName(String name) {this.name name;}public int getAge() {return age;}public void setAge(int age) {this.age age;}public String getColor() {return color;}public void setColor(String color) {this.color color;}
}public class Cat extends Animal{//因为猫类中没有独有的属性。//所以此时不需要写私有的成员变量//空参public Cat() {}//需要带子类和父类中所有的属性public Cat(String name, int age, String color) {super(name,age,color);}
}public class Dog extends Animal{//Dog 吼叫private String wang;//构造public Dog() {}//带参构造带子类加父类所有的属性public Dog(String name, int age, String color,String wang) {//共性的属性交给父类赋值super(name,age,color);//独有的属性自己赋值this.wang wang;}public String getWang() {return wang;}public void setWang(String wang) {this.wang wang;}
}public class Demo {public static void main(String[] args) {//Animal 姓名年龄颜色//Cat ://Dog 吼叫//创建狗的对象Dog d new Dog(旺财,2,黑色,嗷呜~~);System.out.println(d.getName(), d.getAge() , d.getColor() , d.getWang());//创建猫的对象Cat c new Cat(中华田园猫,3,黄色);System.out.println(c.getName() , c.getAge() , c.getColor());}
}
