Day07

最新推荐文章于 2024-04-30 10:29:11 发布
最新推荐文章于 2024-04-30 10:29:11 发布
阅读量75 收藏
点赞数 1
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/SuperYjjj/article/details/113122735
版权

Java学习

文章目录

类与对象

  • 类是一种抽象的数据类型，它是对某一类事物整体描述/定义，但是并不能代表某一个具体的事物。
  • 对象是抽象概念的具体实例。
  • 使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用。
  • **类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。**并且构造器有以下两个特点：
    1. 必须和类的名字相同
    2. 必须没有返回类型，也不能写void
//学生类
public class Student {
    //属性：字段
    String name;
    int age;

    //方法
    public void study(){
        System.out.println(this.name+" 在学习");
    }
}
------------------------------------------------------
//一个项目应该只有一个main方法
public class Application {
    public static void main(String[] args) {

        //类：抽象的，需要实例化
        //类实例化会返回一个自己的对象！
        //student（s1,s2）对象就是一个Student类的具体实例！
        Student s1 = new Student();
        Student s2 = new Student();

        s1.name = " Ben ";
        s1.age = 18;
        s2.name = " Mike ";
        s2.age = 20;
        System.out.println(s1.name+" "+s1.age);
        System.out.println(s2.name+" "+s2.age);

    }
}

构造器

public class Person {

    //一个类即使什么也不写，也会存在一个默认构造方法

    String name;

//    //显示定义构造器
//    //实例化初始值
//    //1、使用new关键字，本质是在调用构造器
//    public Person(){}
//
//
//    //有参构造：一旦定义了有参构造。无参就必须显式定义
//    public Person(String name){
//        this.name = name;
//    }

    //Alt + Insert快速构造方法

    public Person(String name) {
        this.name = name;//this.表示当前类的属性
    }

    public Person() {}
}
/*
    public static void main(String[] args) {

        //new 实例化了一个对象
        Person person = new Person("yjj");//通过new关键字去调用方法

        System.out.println(person.name);
    }
}
 */

创建对象内存分析

public class Pet {
    public String name;
    public int age;

    //无参构造


    public void shout(){
        System.out.println("叫了一声");
    }
}
--------------------------------------------------------
public class Application {
    public static void main(String[] args) {

        Pet dog = new Pet();
        dog.name = "旺财";
        dog.age = 2;
        dog.shout();

        System.out.println(dog.name+" "+dog.age);

        Pet cat = new Pet();

    }
}

在这里插入图片描述

  • 对象是通过引用来操作的：栈---->堆(地址)，真正操作的是堆

封装

  • 该露的露，该藏得藏

    • 程序设计追求**“高内聚，低耦合”**。高内聚：类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用。

  • 封装（数据的隐藏）

    • 通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。

  • 属性私有，get/set

/*
    1、提高程序的安全性，保护数据
    2、隐藏代码的实现细节
    3、统一接口
    4、系统可维护增加了
 */
public class Application {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.setName("yjj");

        System.out.println(s1.getName());
        s1.setAge(999);//不合法的
        System.out.println(s1.getAge());
    }
}
-------------------------------------------------------
//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;
    }
    //Alt + Insert自动生成get/set方法

    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>120||age<0){//不合法
            System.out.print("错误");
        }else{
            this.age = age;
        }
    }
}

继承

  • 继承的本质是对某一批类的抽象，从而实现对现实世界更好地建模

  • extends的意思是“扩展”。子类是父类的扩展

  • Java中类只有单继承，没有多继承，即一个子类只有一个直接父类

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

  • 继承关系的两个类，一个位子类(派生类)，一个为父类(基类)。子类继承父类，使用关键字extends来表示

  • 子类和父类之间，从意义上讲应该具有"is a"的关系

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

    public void say(){
        System.out.println("说了一句话");
    }

    //public
    //protected
    //default
    //private
    private int money = 10_0000_0000;

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }
}
-------------------------------------------------------
//学生 is 人   派生类，子类
//子类继承了父类，就会拥有父类的全部方法！
public class Student extends Person{

}
-------------------------------------------------------
public class Application {
    public static void main(String[] args) {

        Student student = new Student();
        student.say();
        student.setMoney(9_0000_0000);
        System.out.println(student.getMoney());
    }
}
  • object类：在Java中，所有的类，都默认直接或者间接继承Object类
  • super
public class Person {
  public Person() {
      System.out.println("Person无参执行了");
  }
  
  protected String name = "Person,yjj";
  
  public void print(){
      System.out.println("Person");
  }
  //私有的东西无法继承
 }
----------------------------------------------------
public class Student extends Person{

    //隐藏代码：调用了父类的无参构造super();
    public Student() {
        super();//调用父类构造器必须要在子类和构造器的第一行
        System.out.println("Student无参执行了");
    }

    private String name = "Student,yjj";

    public void test1(String name){
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.name);
    }

    public void test2(){
        print();//Student
        this.print();//Student
        super.print();//Person
    }

    public void print(){
        System.out.println("Student");
    }
}
--------------------------------------------------------
public class Application {
    public static void main(String[] args) {

        Student student = new Student();
//        student.test1("YJJ");
//        student.test2();
    }
} 

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

Vs this
    代表的对象不同：
        this：本身调用者这个对象
        super：代表父类对象的应用
    前提
        this：没有继承也可以使用
        super：只能在继承条件下才可以使用
    构造方法
        this();本类的构造
        super();父类的构造
  • 方法重写
  • 重写只能是非静态、public
//重写都是方法的重写，和属性无关
public class B {
    public void test(){
        System.out.println("B->test");
    }
}
-----------------------------------------------------
public class A extends B{

//    public void test(){
//        System.out.println("A->test");
//    }
    //Alt+INS

    //Override 重写
    @Override//注解：有功能的注释！
    public void test() {
        System.out.println("A->test");
    }
}
------------------------------------------------------
public class Application {

    //静态的方法和非静态的方法有很大区别
    //静态方法：方法的调用只和左边，定义的数据类型有关
    //非静态：重写
    public static void main(String[] args) {

        A a = new A();
        a.test();

        //父类的引用指向了子类
        B b = new A();
        b.test();
    }
}   

重写：需要有继承关系，子类重写父类的方法！
    1.方法名必须相同
    2.参数列表必须相同，否则就像重载
    3.修饰符：范围可以扩大：   public > protected > default > private
    4.抛出的异常：范围，可以被缩小，但不能扩大

重写：子类和父类方法一致，方法体不同

为什么需要重写：
    1.父类的功能，子类不一定需要或者不一定满足
    Alt + Insert：override(重写)

多态

  • 动态编译：类型 可扩展性

  • 即同一方法可以根据发送对象的不同而采用多种不同的行为方式

  • 一个对象的实际类型是确定的，但可以指向对象的应用的类型有很多

  • 多态存在的条件

    • 有继承关系
    • 子类重写父类方法
    • 父类引用指向子类对象

  • 注意：多态是方法的多态，属性没有多态性。

public class Person {
    public void run(){
        System.out.println("run");
    }
}
-------------------------------------------------------
public class Student extends Person{
    @Override
    public void run() {
        System.out.println("son");
    }
//    public void run(){
//        System.out.println("son");
//    }
    public void eat(){
        System.out.println("eat");
    }
}
--------------------------------------------------------
public class Application {
    public static void main(String[] args) {

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

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

        //子类能调用的方法都是自己的或者父类的
        Student s1 = new Student();
        //父类可以指向子类但是不能调用子类 独有 的方法
        Person s2 = new Student();//父类的引用指向子类的类型
        Object s3 = new Student();

        s2.run();//子类重写了父类的方法，执行子类的方法
        s1.run();

        //对象能运行哪些方法，主要看左边的类型，和右边关系不大
        //s2.eat();
        s1.eat();
        ((Student) s2).eat();//强制类型转换
    }
}

多态注意事项：
    1.多态是方法的多态，属性没有多态！
    2.父类和子类要有联系，否则类型转换异常！ClassCastException!
    3.存在条件：继承关系；方法重写；父类引用指向子类对象！    Father f1 = new Son();

以下不能重写
1.static 方法属于类，不属于实例，不能重写
2.final 常量
3.private方法
不能重写就没有多态！

父类的方法子类可以调用，子类和父类共同的方法就调用子类，因为子类重写了父类的方法
SuperYjjj
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
python：python基础语法五，类和对象
雷爷的博客
09-20 1256
python基础语法 文章目录python基础语法什么是对象？面向对象（oop）类(class)使用类创建对象的流程类的定义创建对象的流程类的基本结构对象的创建__init__(self)方法 什么是对象？ - 对象是内存中专门用来存储数据的一块区域。 - 对象中可以存放各种数据（比如：数字、布尔值、代码） - 对象由三部分组成： 1.对象的标识（id） 2.对象的类型（type）...
day07-Elasticsearch03
12-13
在本课程"day07-Elasticsearch03"中，我们将深入探讨Elasticsearch这一强大的分布式搜索引擎和数据分析工具。Elasticsearch（ES）是基于Lucene构建的，它以其高效、可扩展性和实时分析能力而备受青睐。在这个阶段的...
java第三次(复习和总结和10月08日所学异常)
qq_45901497的博客
10-08 175
复习: 1.类 类：将具有共同特征和行为的一类实体的集合 普通类：能够实例化对象，调用方法，赋值 抽象类：可以有抽象方法，但是抽象方法不能有方法体（不能有具体实现的大括号),可以定义普通方法,有构造方法,不能new对象 接口类：可以被调用，可以被继承 接口的特点: 接口就是一种引用数据类型 接口中只能定义常量和方法（抽象方法，静态方法，默认方法，私有方法） 接口不能定义成员变量和构造方法 接口不能创建对象，只能通过其实现类来使用 静态类：在java不存在，在NET中存在 接口和抽象类很类似，但是有区别: 抽
python中的类简单讲解
weixin_34383618的博客
07-14 83
      类似其它的语言， Python 中的函数使用小括号( () )调用。函数在调用之前必须先定义。如果函数中没有 return 语句， 就会自动返回 None 对象。      Python 是通过引用调用的。 这意味着函数内对参数的改变会影响到原始对象。不过事实上只有可变对象会受此影响， 对不可变对象来说， 它的行为类似按值调用。 如何定义函数 def function_name...
python中的 new-style class 及其实例详解
朝着梦想 渐行前进
11-01 2967
1.1. 5.2 new-style Class 及其实例 前面我提到 python 2.2 中引入了 new-style 对象模型. new-style class 及其实例与 Classic class 一样, 都是顶级对象。 它们可以拥有任意的属性, 通过调用类对象生成该类的一个实例对象. 在这一小节,我来向大家揭示新的对象模型及传统对象模型的不同. 从 python 2.2
python 类详解
legend_x的专栏
12-11 2183
1.1. 5.2 new-style Class 及其实例 从 python 2.2 起，如果一个类继承自 object 对象(或者它是任何内建类型如 list, dict, file 的子类)，那它就是一个 new-style class 。在此之前，Python 不允许通过继承内建类型生成新类，也根本没有 object 这个对象。在本章5.4节的后半部分，我会介绍给大家一个方法，将 Cl
学习JavaEE的day07
02-28
在“学习JavaEE的day07”这个主题中，我们主要会探讨Java企业级开发的一些核心概念和技术。JavaEE（Java Platform, Enterprise Edition）是Java技术在企业应用开发中的一个框架，它为构建分布式、多层的企业级应用...
day07todo
03-06
第07天 该项目是使用版本10.2.0生成的。 开发服务器 为开发服务器运行ng serve 。 导航到http://localhost:4200/ 。 如果您更改任何源文件，该应用程序将自动重新加载。 代码脚手架 运行ng generate component ...
day07.md
07-13
day07.md
python-Day07.rar
04-07
在Python编程语言的学习过程中，"Day07"可能代表着一个教学日程或者课程模块，重点关注的是第七天所涉及的主题和概念。在这个阶段，学生通常会深入理解Python的基础知识，并逐步接触更高级的话题。以下是根据这个...
Day07实习日记1
08-08
【Java暑期实训——Day07实习日记】 在2017年7月10日的这一天，我在南京华信智源教育科技有限公司的工科楼A203进行了Java实训的第七天。指导老师是张明星，我们主要进行了以下几个方面的学习和实践： 一、回顾与...
day07.xmind
03-04
day07.xmind
Day07日志框架.rar
08-21
本资源“Day07日志框架”可能是针对Python日志模块的一次深入学习和实践教程。 在Python的`logging`模块中，主要有以下几个核心概念： 1. **日志级别**：日志级别用于区分不同严重程度的信息，包括DEBUG、INFO、...
day07-集合 java
06-10
day07-集合 java
MySQL Day07 索引
01-19
MySQL 索引 MySQL官方对索引的定义为：索引是帮助MySQL高效获取数据的数据结构。 提取句子主干，就可以得到索引的本质：索引是数据结构。 1 索引的分类 一个表中主键索引只能有一个，唯一索引可能有多个 ...
Python中的类（Class）详解——新手指南
最新发布
qlkaicx的博客
04-30 4073
在Python编程中，类（Class）是一个非常重要的概念，它允许程序员创建自己的对象类型。这些对象类型可以包含数据（称为属性）和函数（称为方法），它们定义了这些对象的行为。本文将详细介绍Python中类的概念、如何创建和使用类，以及一些基本的面向对象编程原则，使得即使是编程新手也能轻松理解和上手。封装是面向对象编程的一个重要概念，它隐藏了对象的具体实现细节，只向外界提供操作该对象的方法。这意味着不同的类的对象可以调用同一个方法名，但各自有不同的行为。它允许我们定义一个继承另一个类的属性和方法的类。
4、Python中的类详解(0601)
weixin_30273931的博客
07-26 500
《大话数据结构》的作者程杰在博客园也有博客，网址是：http://cj723.cnblogs.com/ 面向对象编程(OOP) 1、程序 = 指令 + 数据 代码可以选择以指令为核心或以数据为核心进行编写 2、两种范型 以指令为核心：围绕“正在发生什么”进行编写 面向过程编程：程序具有一系列线性步骤；主题思想是代码作用于数据 以数据为核心：围绕“将影响谁”进...
Python：类的继承
中志融一的博客
10-11 1407
最近师弟在学习python语言，对于类，继承等基本概念不是很了解，所以写这篇文章来详细的讲解一下继承的概念和在python中的使用。a 单继承定义一个时间类，带默认参数class mytime(object): def __init__(self,hour=21, \ minute=13, \ second=50):
@PostMapping("filters") public Map<String, List<String>> getFilters(@RequestBody RequestParams params){ return hotelService.getFilters(params); }这里调用了HotelService中的getFilters方法，尚未实现。请在下函数中实现：package com.chinasoft.day07index.service; import com.chinasoft.day07index.pojo.Hotel; import com.chinasoft.day07index.pojo.Params; import com.chinasoft.day07index.pojo.SearchResult; import java.util.List; import java.util.Map; public interface HotelService { List<Hotel> getAllHotel(); Hotel getOneHotel(Long id); SearchResult searchMatchHotel(Params params); Map<String, List<String>> filters(Params params); }
07-14
package com.chinasoft.day07index.service; import com.chinasoft.day07index.pojo.Hotel; import com.chinasoft.day07index.pojo.Params; import com.chinasoft.day07index.pojo.SearchResult; import java.util...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值