达内java培训ooday02

最新推荐文章于 2024-09-15 09:47:04 发布
最新推荐文章于 2024-09-15 09:47:04 发布
阅读量463 收藏 9
点赞数 9
分类专栏： 面向对象 文章标签： java python 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_57991760/article/details/138785553
版权

面向对象第二天：

回顾：

  1. 什么是类？什么是对象？

  2. 如何创建类？如何创建对象？如何访问成员？

  3. this：指代当前对象，哪个对象调用方法它指的就是哪个对象

    • this.成员变量名---------------访问成员变量

      当成员变量与局部变量同名时，若想访问成员变量，则this不能省略

  4. 构造方法：

    • 给成员变量赋初值、与类同名、没有返回值类型(连void都没有)，创建(new)对象时被自动调用。若自己不写构造方法，则默认一个无参构造，若自己写了构造方法，则不再默认提供。

精华笔记：

  1. 继承：

    • 作用：代码复用

    • 通过extends实现继承

    • 超类/基类/父类：共有的属性和行为

      派生类/子类：特有的属性和行为

    • 派生类可以访问：超类的+派生类的，超类不能访问派生类的

    • 一个超类可以有多个派生类，一个派生类只能有一个超类---------单一继承

    • 具有传递性

    • java规定：构造派生类之前必须先构造超类

      • 在派生类的构造方法中若没有调用超类的构造方法，则默认super()调用超类的无参构造方法

      • 在派生类的构造方法中若自己调用了超类的构造方法，则不再默认提供

        注意：super()调用超类构造方法，必须位于派生类构造方法中的第1行

  2. super：指代当前对象的超类对象

    • super.成员变量名-------------------------访问超类的成员变量

      当超类成员变量和派生类成员变量同名时，super指超类的，this指派生类的

      若没有同名现象，则写super和this是一样的

    • super.方法名()------------------------------调用超类的方法

    • super()----------------------------------------调用超类的构造方法

  3. 方法的重写(override/overriding)：重新写、覆盖

    • 发生在父子类中，方法名相同，参数列表相同

    • 重写方法被调用时，看对象的类型---------------new谁就调谁的，这是规定

      class 餐馆{
    void 做餐(){ 做中餐 }
}
//1)我还是想做中餐----------------------不需要重写
class Aoo extends 餐馆{
}
//2)我想改做西餐------------------------需要重写
class Boo extends 餐馆{
    void 做餐(){ 做西餐 }
}
//3)我想在中餐基础之上加入西餐------------需要重写(先super中餐，再加入西餐)
class Coo extends 餐馆{
    void 做餐(){
        super.做餐();
        做西餐
    }
}

  4. final：最终的、不能改变的------------单独应用几率低

    • 修饰变量：变量不能被改变

    • 修饰方法：方法不能被重写

    • 修饰类：类不能被继承

笔记：

  1. 继承：

    • 作用：代码复用

    • 通过extends实现继承

    • 超类/基类/父类：共有的属性和行为

      派生类/子类：特有的属性和行为

    • 派生类可以访问：超类的+派生类的，超类不能访问派生类的

    • 一个超类可以有多个派生类，一个派生类只能有一个超类---------单一继承

    • 具有传递性

      public class Person {
    String name;
    int age;
    String address;
    void eat(){
        System.out.println(name+"正在吃饭...");
    }
    void sleep(){
        System.out.println(name+"正在睡觉...");
    }
    void sayHi(){
        System.out.println("大家好，我叫"+name+"，今年"+age+"岁了，家住"+address);
    }
}
public class Student extends Person{
    String className;
    String stuId;
    Student(){
    }
    Student(String name,int age,String address,String className,String stuId){
        super.name = name;
        super.age = age;
        super.address = address;
        this.className = className;
        this.stuId = stuId;
    }

    void study(){
        System.out.println(name+"正在学习...");
    }
}
public class Teacher extends Person {
    double salary;
    Teacher(){
    }
    Teacher(String name,int age,String address,double salary){
        this.name = name;
        this.age = age;
        this.address = address;
        this.salary = salary;
    }

    void teach(){
        System.out.println(name+"正在讲课...");
    }
}
public class Doctor extends Person {
    String title;
    Doctor(){
    }
    Doctor(String name,int age,String address,String title){
        this.name = name;
        this.age = age;
        this.address = address;
        this.title = title;
    }

    void cut(){
        System.out.println(name+"正在做手术...");
    }
}
public class ExtendsTest {
    public static void main(String[] args) {
        Student zg = new Student();
        zg.name = "张光";
        zg.age = 23;
        zg.address = "廊坊";
        zg.className = "jsd2311";
        zg.stuId = "001";
        zg.eat();
        zg.sleep();
        zg.sayHi();
        zg.study();

        Student ll = new Student("李林",22,"佳木斯","jsd2311","002");
        ll.eat();
        ll.sleep();
        ll.sayHi();
        ll.study();

        Teacher zl = new Teacher("赵亮",36,"山东",6000.0);
        zl.eat();
        zl.sleep();
        zl.sayHi();
        zl.teach();

        Doctor wpf = new Doctor("王鹏飞",45,"山西","主任医师");
        wpf.eat();
        wpf.sleep();
        wpf.sayHi();
        wpf.cut();

        //演示超类不能访问派生类的
        Person p = new Person();
        p.name = "人";
        p.age = 1;
        p.address = "未知";
        p.eat();
        p.sleep();
        p.sayHi();
        //p.stuId = "005"; //编译错误，超类不能访问派生类的
    }
}

    • java规定：构造派生类之前必须先构造超类

      • 在派生类的构造方法中若没有调用超类的构造方法，则默认super()调用超类的无参构造方法

      • 在派生类的构造方法中若自己调用了超类的构造方法，则不再默认提供

        注意：super()调用超类构造方法，必须位于派生类构造方法中的第1行

        public class Person {
    String name;
    int age;
    String address;
    Person(){
    }
    Person(String name,int age,String address){
        this.name = name;
        this.age = age;
        this.address = address;
    }

    void eat(){
        System.out.println(name+"正在吃饭...");
    }
    void sleep(){
        System.out.println(name+"正在睡觉...");
    }
    void sayHi(){
        System.out.println("大家好，我叫"+name+"，今年"+age+"岁了，家住"+address);
    }
}

public class Student extends Person{
    String className;
    String stuId;
    Student(){
    }
    Student(String name,int age,String address,String className,String stuId){
        super(name,age,address);
        this.className = className;
        this.stuId = stuId;
    }

    void study(){
        System.out.println(name+"正在学习...");
    }
}

public class Teacher extends Person{
    double salary;
    Teacher(){
    }
    Teacher(String name,int age,String address,double salary){
        super(name,age,address);
        this.salary = salary;
    }

    void teach(){
        System.out.println(name+"正在讲课...");
    }
}

public class Doctor extends Person {
    String title;
    Doctor(){
    }
    Doctor(String name,int age,String address,String title){
        super(name,age,address);
        this.title = title;
    }
    void cut(){
        System.out.println(name+"正在做手术...");
    }
}

  2. super：指代当前对象的超类对象

    • super.成员变量名-------------------------访问超类的成员变量

      当超类成员变量和派生类成员变量同名时，super指超类的，this指派生类的

      若没有同名现象，则写super和this是一样的

    • super.方法名()------------------------------调用超类的方法

    • super()----------------------------------------调用超类的构造方法

      public class SuperDemo {
    public static void main(String[] args) {
        Boo o = new Boo();
    }
}

//1)在派生类的构造方法中若没有调用超类的构造方法，则默认super()调用超类的无参构造方法
class Aoo{
    Aoo(){
        System.out.println("超类构造方法");
    }
}
class Boo extends Aoo{
    Boo(){
        super(); //默认的，调用超类的无参构造方法
        System.out.println("派生类构造方法");
    }
}

//2)在派生类的构造方法中若自己调用了超类的构造方法，则不再默认提供
class Coo{
    Coo(int a){
    }
}
class Doo extends Coo{
    Doo(){
        super(5); //调用超类的有参构造
    }
    /*
    //如下代码为默认的:
    Doo(){
        super();
    }
     */
}

  3. 方法的重写(override/overriding)：重新写、覆盖

    • 发生在父子类中，方法名相同，参数列表相同

    • 重写方法被调用时，看对象的类型---------------new谁就调谁的，这是规定

      class 餐馆{
    void 做餐(){ 做中餐 }
}
//1)我继承餐馆后还是想做中餐---------------不需要重写
class Aoo extends 餐馆{
}
//2)我继承餐馆后想改做西餐-----------------需要重写
class Boo extends 餐馆{
    void 做餐(){ 做西餐 }
}
//3)我继承餐馆后想在中餐基础之上加入西餐------需要重写(先super中餐，再加入西餐)
class Coo extends 餐馆{
    void 做餐(){
        super.做餐();
        做西餐
    }
}

      public class Person {
    String name;
    int age;
    String address;
    Person(){
    }
    Person(String name,int age,String address){
        this.name = name;
        this.age = age;
        this.address = address;
    }

    void eat(){
        System.out.println(name+"正在吃饭...");
    }
    void sleep(){
        System.out.println(name+"正在睡觉...");
    }
    void sayHi(){
        System.out.println("大家好，我叫"+name+"，今年"+age+"岁了，家住"+address);
    }
}

public class Student extends Person{
    String className;
    String stuId;
    Student(){
    }
    Student(String name,int age,String address,String className,String stuId){
        super(name,age,address); //传递的是name/age/address的值
        this.className = className;
        this.stuId = stuId;
    }

    void study(){
        System.out.println(name+"正在学习...");
    }
    
    void sayHi(){
        System.out.println("大家好，我叫"+name+"，今年"+age+"岁了，家住"+address+"，所在班级为:"+className+"，学号为："+stuId);
    }
}

public class Teacher extends Person{
    double salary;
    Teacher(){
    }
    Teacher(String name,int age,String address,double salary){
        super(name,age,address);
        this.salary = salary;
    }

    void teach(){
        System.out.println(name+"正在讲课...");
    }
    
    void sayHi(){
        System.out.println("大家好，我叫"+name+"，今年"+age+"岁了，家住"+address+"，工资为:"+salary);
    }
}

public class Doctor extends Person {
    String title;
    Doctor(){
    }
    Doctor(String name,int age,String address,String title){
        super(name,age,address);
        this.title = title;
    }
    void cut(){
        System.out.println(name+"正在做手术...");
    }
}

public class OverrideDemo {
    public static void main(String[] args) {
        //重写方法被调用时，看对象的类型执行方法(new谁就调谁)
        Student zg = new Student("张光",23,"廊坊","jsd2309","001");
        zg.sayHi(); //调用Student重写之后的
        Teacher ll = new Teacher("李林",35,"佳木斯",6000.0);
        ll.sayHi(); //调用Teacher重写之后的
        Doctor zl = new Doctor("赵亮",45,"山东","主任医师");
        zl.sayHi(); //调用Person中的
    }
}

  4. final：最终的、不能改变的------------单独应用几率低

    • 修饰变量：变量不能被改变

      class Eoo{
    final int a = 5;
    int b = 6;
    void test(){
        //a = 55; //编译错误，final修饰的变量不能被改变
        b = 66;
        final int c = 8;
        //c = 88; //编译错误，final修饰的变量不能被改变
    }
}

    • 修饰方法：方法不能被重写

      class Foo{
    final void show(){}
    void test(){}
}
class Goo extends Foo{
    //void show(){} //编译错误，final修饰的方法不能被重写
    void test(){}
}

    • 修饰类：类不能被继承

      final class Hoo{}
//class Ioo extends Hoo{} //编译错误，final修饰的类不能被继承
class Joo{}
final class Koo extends Joo{} //正确，不能当老爸，但能当儿子

  5. 综合练习：

    public class Animal {
    String name;
    int age;
    String color;
    Animal(){
    }
    Animal(String name,int age,String color){
        this.name = name;
        this.age = age;
        this.color = color;
    }
    void drink(){
        System.out.println(color+"色的"+age+"岁的"+name+"正在喝水...");
    }
    void eat(){ //明天继续做处理
        System.out.println(color+"色的"+age+"岁的"+name+"正在吃饭...");
    }
}

public class Dog extends Animal {
    Dog(){
    }
    Dog(String name,int age,String color){
        super(name,age,color);
    }
    void lookHome(){
        System.out.println(color+"色的"+age+"岁的狗狗"+name+"正在看家...");
    }
    void eat(){
        System.out.println(color+"色的"+age+"岁的狗狗"+name+"正在吃肯头...");
    }
}

public class Chick extends Animal {
    Chick(){
    }
    Chick(String name,int age,String color){
        super(name,age,color);
    }
    void layEggs(){
        System.out.println(color+"色的"+age+"岁的小鸡"+name+"正在下蛋...");
    }
    void eat(){
        System.out.println(color+"色的"+age+"岁的小鸡"+name+"正在吃小米...");
    }
}

public class Fish extends Animal {
    Fish(){
    }
    Fish(String name,int age,String color){
        super(name,age,color);
    }
    void eat(){
        System.out.println(color+"色的"+age+"岁的小鱼"+name+"正在吃小虾...");
    }
}

public class AnimalTest {
    public static void main(String[] args) {
        Dog dog = new Dog("小黑",2,"黑");
        dog.eat();
        dog.drink();
        dog.lookHome();

        Chick chick = new Chick("小花",1,"花");
        chick.eat();
        chick.drink();
        chick.layEggs();

        Fish fish = new Fish("小金",2,"金");
        fish.eat();
        fish.drink();
    }
}

补充：

  1. 泛化：从程序设计角度而言叫泛化，从代码实现角度而言叫继承，泛化就是继承

  2. 继承要符合is(是)的关系

  3. 继承的是父类的成员变量和普通方法，不包括构造方法，父类的构造方法是被子类通过super来调用的

    class Aoo{
    int a;
    Aoo(){
    }
    void show(){
    }
}
class Boo extends Aoo{
    继承了Aoo类的a+show()，并没有继承Aoo类的构造方法
}

  4. 重写与重载的区别：-------------------常见面试题

    • 重写(overriding)：发生在父子类中，方法名相同，参数列表相同
    • 重载(overloading)：发生在同一类中，方法名相同，参数列表不同

  5. 重载特例情况：

    class Aoo{
    void show(){
    }
}
class Boo extends Aoo{ //在此类中发生了show()的重载
    void show(String name){
    }
}

  6. 明日单词：

    1)swim:游泳
2)abstract:抽象的
3)interface:接口
4)implements:实现
小锅锅氩
关注
专栏目录
达内java培训内部资料pdf 百度网盘下载(有效地址)
09-18
达内java培训内部资料，pdf格式，下载后请复制链接到百度网盘下载.struts,spring,Servlet,JSP,hibernate,ajaxjuery
达内java培训笔记
08-10
达内教育是一家知名的IT培训机构，其Java培训课程备受学员欢迎。这份“达内java培训笔记”涵盖了Java学习的重要概念和关键知识点，旨在帮助学员深入理解和掌握这门强大的语言。 一、Java基础 Java的基础包括语法、...
【OO面向对象基础】继承、super、重写、引用类型数组、null
qq_36028783的博客
02-22 264
【代码】【OO面向对象基础】继承、super、重写、引用类型数组、null。
JAVA面向对象
zmt147258的博客
11-10 358
JAVA面向对象知识总结
面向对象1
weixin_67883701的博客
03-28 120
什么是类？什么是对象？ 现实生活中是由很多很多对象组成的，基于对象抽出了类 对象：软件中真实存在的单个个体/东西 类：类别/类型，代表一类个体 类是对象的模子，对象是类的具体的实例 类中可以包含： 对象的属性/特征-----------------------成员变量 对象的行为/动作-----------------------方法 一个类可以创建多个对象 如何创建类？如何创建对象？如何访问成员？ 方法的重载(overload/overloading)： 发生在同一类中，方法名相.
JAVA中所有对象的超类是_在Java中获取对象的超类
weixin_26824207的博客
03-01 526
可以使用java.lang.Class.getSuperclass()方法获得任何实体的直接超类，例如对象，类，原始类型，接口等。此方法不包含任何参数。演示此的程序如下所示-示例publicclassMain{publicstaticvoidmain(String[]args){Objectobj1=newString("Hello");Objectobj2=new...
JAVA中所有对象的超类是_为什么对象类是Java中所有类的超类？
weixin_29145157的博客
03-01 463
Java.lang.Object类是类层次结构的根或超类，存在于java.lang软件包中。所有预定义的类和用户定义的类都是Object类的子类。为什么对象类是超类重用性每个对象都有11通用属性，每个Java开发人员都必须实现这些属性。为了减轻开发人员的负担，SUN通过使用11种方法实现所有这11属性，开发了一个名为Object的类。所有这些方法都具有所有子类通用的通用逻辑，如果该逻辑不满足子类要...
达内java培训ooday01
qq_57991760的博客
05-11 761
什么是类？什么是对象？现实生活是由很多很多对象组成的，基于对象抽出了类对象：软件中真实存在的单个的个体/东西类：类型/类别，代表一类个体类是对象的模子/模板，对象是类的具体的实例，可以将类理解为类别/模子/图纸一个类可以创建多个对象如何创建类？如何创建对象？如何访问成员？this：指代当前对象，哪个对象调用方法它指的就是哪个对象只能用在方法中，方法中访问成员变量之前默认有个this.this的用法：this.成员变量名--------------------访问成员变量(必须掌握)
达内java培训ooday03
qq_57991760的博客
05-13 1443
继承：代码复用、extends、超类:共有的 派生类:特有的派生类可以访问派生类的和超类的，但超类不能访问派生类的单一继承，具有传递性java规定：构造派生类之前必须先构造超类若派生类的构造方法中没有调用超类构造方法，则默认super()调超类无参构造方法若派生类的构造方法中调用了超类构造方法，则不再默认提供super()调用超类构造方法，必须位于派生类构造方法的第1行super：指代当前对象的超类对象。
2017达内java最新培训视频
06-22
2017 达内 java 最新 培训 视频
达内JAVA培训课件
08-05
达内PPT授课课件完整版，很不错的哦，当年学习时跟老师商量半天才给的，今天无意中找到
达内 java 全套视频百度云分享
02-05
达内 java 全套视频包括java spring mybatis jdbc struts hibernate等
Java-网络
2301_81543552的博客
09-14 693
Java中的网络编程主要涉及使用Socket类进行网络通信，以及理解各种网络协议。以下是一些关键概念和示例代码，帮助您入门。
Android Studio 2024与2022 解决Read timed out和connect timed out的问题
2301_80035882的博客
09-14 602
如果在新建Android项目时报错：Read timed out或者connect timed out。
自动生成不重复的订单id
ClaireCheney的博客
09-13 277
【代码】自动生成不重复的订单id。
【学习笔记】手写 Tomcat 三
LearnTech_123的博客
09-12 1134
响应动态资源不需要写文件名了，只需要写功能的名称即可。比如登录功能，可以定义名称为 doLogin
Gradle
最新发布
xiaocaij_icai的博客
09-15 185
");
基于SpringBoot的考研资讯平台设计与实现
linzhongshu的专栏
09-13 915
对于本次的系统开发来看，它主要是把我以前所学的知识进行了一次综合的应用。经过这次毕业设计的制作它主要是把我以前所学的理论知识应用到社会实践当中。通过这一次的考研资讯平台的设计与实现它能够有效把计算机知识与实际问题相互应用，通过计算机网络技术来解决学生生活当中的实际问题，从而提高我的编程能力。虽然在这次毕业设计当中我遇到了很多的问题和困难，但是通过不断的调试和老师的帮助让我圆满的完成了这次毕业设计。
达内Java培训：海外师资与企业实战教程
达内Java基础PPT是达内信息技术有限公司提供的专业培训材料，针对想要学习Java语言的个人或希望提升技能的IT专业人士。该课程以海外师资力量和北美技术为基础，强调的是结合外企经验和实战教学，旨在帮助学员掌握...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值