Java基础Day05

最新推荐文章于 2022-08-21 18:22:53 发布
最新推荐文章于 2022-08-21 18:22:53 发布
阅读量60 收藏
点赞数
分类专栏： Java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xyfighting001/article/details/113037321
版权

面向对象–>三大特性

1.封装（数据的隐藏）

  • 高内聚：类的内部数据操作细节自己完成，不允许外部干涉。
  • 低耦合：仅暴露少量的方法给外部使用。
  • 信息隐藏：应当禁止直接访问一个对象中数据的实际表示，而是应该通过操作接口来访问。
  • 属性私有，get/set
package com.oop.demo04;

//类 private私有
public class Student {

    //属性私有
    private String name;//名字
    private int id;//学号
    private char sex;//性别
    private int age;//年龄

    //提供一些可以操作这个属性的方法！
    //提供一些public的get/set方法

    //get 获取这个数据
    public String getName() {
        return this.name;
    }
    //set 给这个数据设置值

    public void setName(String name) {
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if (age < 0 || age>120) {
            this.age = 3;
        }else {
            this.age = age;
        }
    }
}
/*
 Student student = new Student();
        student.setName("栀夏");
        System.out.println(student.getName());

        student.setAge(999);//不合法的
        System.out.println(student.getAge()+"岁");
 */

封装的意义

  1. 提高程序的安全性，保护数据
  2. 隐藏代码的实现细节
  3. 统一接口
  4. 系统的可维护性增加了

2.继承

  • 本质：对某一批类的抽象。

  • Java中类只有单继承，没有多继承！

  • 继承是类与类之间的一种关系。除此之外，类与类之间关系还有依赖、组合、聚合等关系

  • 继承关系的二个类，子类（派生类）是父类（基类)的扩展。子类继承父类，使用关键字extends来表示。

Person类：

package com.oop.demo05;

//在Java中，所有的类 直接或者间接继承Object类
//Person 人:父类
public class Person {

    //public 公有
    //protected
    //default
    //private 私有的
    int money = 10_0000_0000;
    public void say(){
        System.out.println("狗狗叫了一声！");
    }

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }
}

Student类：

package com.oop.demo05;

//学生 is 人:派生类，子类
//子类继承父类 就会拥有父类的全部方法
//类里面按CTRL+H 继承树
public class Student extends Person{

}

Teacher类：

package com.oop.demo05;

//teacher is 人
public class Teacher extends Person{

    Person person;
}

object类

//在Java中，所有的类 直接或者间接继承Object类

super

Person类：

package com.oop.demo06;

public class Person /*extends Object*/{

    protected String name = "zhixia";

    public Person(String name) {
    }

    //私有的东西无法被继承
    public void print(){
        System.out.println("person");
    }
}

Student类：

package com.oop.demo06;

public class Student extends Person{

    public Student(){
        super("name");
        System.out.println("无参构造了！");
    }



    private String name = "栀夏";

    public void test(String name){
        System.out.println(name);//haha
        System.out.println(this.name);//栀夏
        System.out.println(super.name);//zhixia
    }
    public void print(){
        System.out.println("student");
    }

    public void test1(){
        print();//student
        this.print();//student
        super.print();//person
    }
}

super注意点：

  1. super调用父类的构造方法，必须在构造方法的第一个
  2. super必须只能出现在子类的方法或者构造方法中！
  3. super和this不能同时调用构造方法！

super VS this:

  1. 代表的对象不同：
    • this：本身调用者这个对象
    • super：代表父类对象的应用
  2. 前提：
    • this:没有继承也可以使用
    • super：只能在继承条件下才可以使用
  3. 构造方法：
    • this()：本类的构造
    • super()：父类的构造

方法重写（重点）

B类：

package com.oop.demo06;

//重写都是方法的重写，和属性无关
public class B {

    /*静态
    public static void test(){
        System.out.println("B=>test()");
    }
     */

    //非静态
    public void test(){
        System.out.println("B=>test()");
    }
}

A类：

package com.oop.demo06;

//继承
public class A extends B{

    /*静态
     public static void test() {
        System.out.println("A->test()");
    }
     */
  
  
    //非静态
    //Overwrite：重写
    @Override//注解：有用功能的注释！
    public void test() {
        System.out.println("A->test()");
    }
}

Application类：

package com.oop;


import com.oop.demo06.A;
import com.oop.demo06.B;

public class Application {

    //静态的方法和非静态的方法区别很大

    public static void main(String[] args) {
/*
        //静态方法：方法的调用只和左边，定义的数据类型有关
        A a = new A();
        a.test();//A=>test()
        //父类的引用指向了子类
        B b = new A();
        b.test();//B=>test()
 */
        //非静态方法：重写（public）
        A a = new A();
        a.test();//A=>test()
       
        B b = new A();//子类重写了父类的方法
        b.test();//A=>test()
    }
}

注意点：

  1. 需要有继承关系，子类重写父类的方法
  2. 方法名必须相同
  3. 参数列表必须相同
  4. 修饰符，范围可以扩大但不能缩小：public>Protected>Default>private
  5. 抛出的异常：范围，可以被缩小但不能被扩大：ClassNotFoundException —> Exception(大)

重写：子类与父类的方法相同，但是方法体内容不一样！

为什么需要重写？

  1. 父类的功能，子类不一定需要或者不一定满足。
  2. 快捷键：Alt + insert : Overrite;

3.多态

  1. 同一个方法可以根据发送对象的不同而采用多种不同的行为方式
  2. 一个对象的实际类型是确定的，但是可以指向对象的引用的类型有很多（父类，有关系的类）
  3. 多态存在的条件
    • 有继承关系
    • 子类重写父类方法
    • 父类引用指向子类对象
  4. 多态是方法的多态，属性没有多态特性

person类：

package com.oop.demo07;

public class Person {

    public void run(){
        System.out.println("run");
    }
}

Student类：

package com.oop.demo07;

public class Student extends Person{

    @Override
    public void run() {
        System.out.println("son");
    }

    public void eat(){
        System.out.println("eat");
    }
}

Application类：

package com.oop;


import com.oop.demo07.Person;
import com.oop.demo07.Student;

public class Application {

    public static void main(String[] args) {

        //一个对象的实际类型是确定的
        //new Student();
        //new Person();

        //可以指向的引用类型就不确定了:父类的引用指向子类

        //Student：能调用的方法的或者继承父类的
        Student s1 = new Student();
        //Peson：可以指向子类 但是不能调用子类独有的方法
        Person s2 = new Student();
        Object s3 = new Student();


        //能执行哪些方法，主要看对象左边的类型和右边的关系不大
        s2.run();//son //子类重写了父类的方法，执行子类的方法
        s1.run();//son

        ((Student) s2).eat();//eat //强制转换
        s1.eat();//eat
      
    }
}

多态注意事项：

  1. 多态是方法的多态，属性没有多态
  2. 父类和子类，有联系。 类型转换异常！ClassCastException!
  3. 存在条件：继承关系，方法需要重写，父类的引用指向子类对象！ Father f1 =new Son();
  4. 无法被重写的
    • static 静态方法，属于类，不属于实例
    • final 常量
    • private 私有方法

instanceof

类型转换 引用类型，判断一个对象是什么类型

Application类：

package com.oop;


import com.oop.demo07.Person;
import com.oop.demo07.Student;
import com.oop.demo07.Teacher;

public class Application {

    public static void main(String[] args) {

        //System.out.println(X instanceof Y);能否编译通过 看X和Y是否具有父子关系
        //Object >String
        //Object >Person >Student
        //Object >Person >Teacher
        Object object = new Student();

        System.out.println(object instanceof Student);//true
        System.out.println(object instanceof Person);//true
        System.out.println(object instanceof Object);//true
        System.out.println(object instanceof Teacher);//false
        System.out.println(object instanceof String);//false

        System.out.println("=============================");
        Person person = new Student();
        System.out.println(person instanceof Student);//true
        System.out.println(person instanceof Person);//true
        System.out.println(person instanceof Object);//true
        System.out.println(person instanceof Teacher);//false
        //System.out.println(person instanceof String);//编译出错！

        System.out.println("==========================");
        Student student = new Student();
        System.out.println(student instanceof Student);//true
        System.out.println(student instanceof Person);//true
        System.out.println(student instanceof Object);//true
        //System.out.println(student instanceof Teacher);//编译出错！
        //System.out.println(student instanceof String);//编译出错！
    }
}

类型转换

Application类：

package com.oop;


import com.oop.demo07.Person;
import com.oop.demo07.Student;

public class Application {

    public static void main(String[] args) {

        //类型之间的转换：父  子

        //高 （父）         低（子）
        Person obj = new Student();

        //student将这个对象转换为Student类型就可以使用Student类型的方法了
        //1.((Student) obj).go();
        //2.
             Student student = (Student) obj;
             student.go();

        //子             父
        Student student1 = new Student();
        student1.go();
        //子类转换为父类 可能丢失自己的一些方法
        Person person = student1;
    }
}

注意点：

  1. 父类引用指向子类对象
  2. 把子类转换为父类 向上转型
  3. 父类转换为子类，向下转型 强制转换
  4. 方便代码的使用，减少重复的代码！简洁
栀夏❀
关注
专栏目录
java基础 Day05 内部类、Object类、匿名内部类；方法的覆写；抽象类和接口
华山栈道的博客
04-17 1610
目录1. 设计一个工资管理系统，针对两种雇员的工资进行管理：长期合同工、短期小时工；2. 编写Addition类，该类中应包含一组实现两数相加运算的重载方法。3. 创建一个Vehicle类并将它声明为抽象类。 1. 设计一个工资管理系统，针对两种雇员的工资进行管理：长期合同工、短期小时工； 合同工的工资按月发放，小时工的工资为每小时工资乘以工作小时数；都是月底结算； 如果当月为雇员生日所在月，则当月加发200元的贺金； 建立一个雇员父类Employee，两种雇员类继承Employee类； 利用循环结构
Java基础day01
07-20
Java是一种广泛应用于各种领域的编程语言，尤其在企业级应用开发中占据着主导地位...从第一天的Java基础学习开始，随着对语言特性的理解和实践，开发者可以逐步构建起坚实的技术基础，从而在各种领域中发挥Java的优势。
java 实现接口和继承关系
11-23
实现接口和继承关系，每个类都有普通方法和构造方法
java继承
qq_30906791的博客
09-09 194
java继承 在Java语言中，类可以从其他类派生，从而从这些类继承字段和方法。（classes can be derived from other classes, thereby inheriting fields and methods from those classes.） 定义：从另一个类派生的类称为子类（也称为派生类，扩展类或子类）。 派生子类的类称为超类（也称为基类或父类）。 除了没有超类的Object类之外，每个类都有且只有一个直接超类（单继承）。 在没有其他任何显式超类的情况下，每个类都
Java中重写的概念及特点
link的博客
08-23 520
重写：不同类同名同参，功能不同 被重写：父类方法。 重写：子类方法。 重写是子类继承父类后，可以对父类中同名的方法的覆盖操作。 重写方法时修改方法体，通过子类对象调用的方法内容是子类方法的方法体。 重写方法和被重写方法的参数列表一致。 如果被重写方法的返回值类型是A类型的，则重写方法的返回值类型只能是A类型。 重写方法的访问权限不能小于被重写方法的访问权限。 若父类中被重写的方法是被private修饰的，则子类无法重写此方法。 ...
Java - 重写
qq_60213361的博客
03-21 1436
一、什么是重写 　　在子类中创建了一个与父类中名称相同、返回值类型相同、参数列表的方法相同，只是方法体中的实现不同，以实现不同于父类的功能，这种方式被称为方法重写（override），又称为方法覆盖、方法复写。 二、为什么需要重写 　　原有的方法无法满足新的需求，需要对这个方法进行改良来满足新的需求。重写是出现在子类继承父类方法中。可以看出，重写就是子类继承的父类方法无法满足子类的新的功能需求，子类对父类的这个方法进行改良重写的一种方式。子类可以根据需要，定义特定于自己的行为。既沿袭了父类的功能名..
java重写是什么意思_java中的重写是什么意思
weixin_36163101的博客
02-13 2675
java中的重写是什么意思发布时间：2020-07-01 19:05:25来源：亿速云阅读：145作者：Leahjava中的重写是什么意思？很多新手对此不是很清楚，为了帮助大家解决这个难题，下面小编将为大家详细讲解，有这方面需求的人可以来学习下，希望你能有所收获。java的重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写...
Java基础Day05.xmind
06-29
适合java初学者
Java入门基础学习资料day05-06
最新发布
10-22
此java基础课程，适合0基础小白，课程一共11天课时，目录如下： day01【前言、入门程序、常量、变量】 day02【数据类型转换、运算符、方法入门】 day03【流程控制语句】 day04【 Idea、方法】 day05【数组】 day06...
Java基础day03(ppt文档).pptx
11-13
Java基础day03（ppt文档） 本章节主要介绍了Java语言的基本语法，包括数据类型的转换、运算符的介绍、运算符的优先级、语句的介绍等内容。 1. 数据类型的转换 Java中可以进行不同数据类型的加减乘除运算吗？答案...
JAVA重载概念
11-18
在Java 中，同一个类中的2个或2个以上的方法可以有同一个名字，只要它们的参数声明不同即可。在这种情况下，该方法就被称为重载（overloaded ），这个过程称为方法重载（method overloading ）。方法重载是Java 实现多态性的一种方式。如果你以前从来没有使用过一种允许方法重载的语言，这个概念最初可能有点奇怪。但是你将看到，方法重载是Java 最激动人心和最有用的特性之一。
Java重写和重载概念及区别梳理
03-21
NULL 博文链接：https://zhycaf.iteye.com/blog/980334
java什么是重写_java中重写是什么
weixin_39599317的博客
02-20 447
当子类需要父类的功能，而子类有新的内容，可以重写父类中的方法。在实际开发过程中，随着代码量的逐渐增加，维护成了一个很大的问题，如果需要对某个方法进行修改，其本身代码以及其子类代码都会受到影响，而重写则很好的解决了这个问题。方法重写又称为方法覆盖、方法复写。 (推荐学习：java课程)重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。方法重写特点在子类...
【Java】中什么是重写
Junnix的博客
12-20 2995
Java中什么是重写 1：子类继承父类的时候：如果子类对象不想使用父类的方法体，需要在子类中重写一个与父类同名的方法体，之后子类对象调用此方法的时候，自动调用子类的方法体。 2：子类实现接口的时候：必须重写接口中的所有方法。以实现接口的“规范性”作用。 .........
Java中的重写
AOOOOO李
11-23 150
重写：需要有继承关系，子类重写父类的方法！ 方法名必须相同 参数列表必须相同 修饰符：范围可以扩大但不能缩小： public>protected>default>private 抛出的异常：范围 ，可以被缩小，但不能扩大 ： ClassNotFoundException> exception(大) 重写 子类的方法和父类必须要一致 方法体不同！ 为什么需要重写： ​ 父类的功能 子类不一定需要 或者不一定满足 ​ Alt + Inse
【JAVA学习】5.重写的概念理解和多态、final
枫色的专栏
04-23 638
六、重写的概念理解和多态 重写不是覆盖，是子类拥有一个跟父类一样的方法。 在继承环境下，子类认可父类的行为（认同和坚持方法的签名），但对行为的具体执行过程不认可，则决定对父亲这个方法进行局部或者完全的更新。 重写的模式从内容实现上分为2种： 1.改良性，补充型重写：对父亲提供的方法内容进行补充。 2.颠覆性重写：完全否定父亲所提供的方法内容，彻底改写。 重写不...
JAVA 基本概念之重载和重写
景枫-Hunter的博客
08-02 468
今天来回顾下Java基本概念中的重载和重写。 重载（Overloading）：在同一类中出现相同的方法名，但参数列表不同的方法，这种情况就是重载。         规则：方法名相同                    参数列表不同                    返回类型可以不同        eg： public class OverloadingDemo { //
Java中的重写(Override)
weixin_68105699的博客
08-21 1997
Java中的重写(Override)
Java基础教程：Day01-变量与数据类型解析
"一起学Java—Day01：Java基础语法，包括注释、变量、数据类型和Scanner类的应用及printf()的相关知识" 在Java编程语言中，掌握基础语法是学习的关键步骤。本文主要涵盖了以下几个方面： 1. **Java中的注释**： ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值