[java学习笔记]-面向对象(1)

最新推荐文章于 2024-07-13 13:55:40 发布
最新推荐文章于 2024-07-13 13:55:40 发布
阅读量215 收藏
点赞数
分类专栏： java基础 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/noob0208/article/details/125963557
版权

[java学习笔记]-面向对象_1

面向对象编程(OOP)

面向对象编程的本质就是:以类的方式组织代码, 以对象的组织(封装)数据

特征：

封装
继承
多态

准备:方法

◆方法的定义
    ◆修饰符
    ◆返回类型
    ◆break 和return的区别
    ◆方法名
    ◆参数列表
    ◆异常抛出
◆方法的调用
    ◆静态方法
    ◆非静态方法
    ◆形参和实参
    ◆值传递和引用传递
    ◆this关键字

简单 sayHello 函数

/**
 * 修饰符 返回值类型 方法名(.参数.){
 *     //方法体
 *     return 返回值;
 * }
 */
public String sayhello(){
    return "hello world!";
}

void 类型 不需要写返回值 或者是空

public void hello(){
  return;            //返回是空值
}

简单比大小方法

public static int max(int a, int b){
    return a>b ? a : b;              //三元运算符!!!!
}

break 和 return 的区别

break:
    跳出 switch,结束循环
return:
    结束方法，返回一个结果

方法名 : 驼峰命名法 见名知意

方法的调用

静态方法    //static

非静态方法  //无 static

非静态方法

//非静态方法
//Student.java

//学生类
public class Student {
    //非静态方法
    public void hello(){
        System.out.println("我是学生");
    }
}

//Demo2.java
public class Demo2 {
    public static void main(String[] args) {
        //实例化学生类 new
        //对象类型 对象名 = 对象值
        Student student = new Student();
        student.hello();
    }
}

在这里插入图片描述

形参和实参

public class Demo3 {
    public static void main(String[] args) {
        //实际参数和形式参数的类型要对应
        int add = new Demo3().add(2, 3);
        System.out.println(add);
    }
    public int add(int a, int b){
        return a + b;
   }
}

添加 static 修饰符

public class Demo3 {
    public static void main(String[] args) {
        //实际参数和形式参数的类型要对应
        int add = Demo3.add(3, 2);
        System.out.println(add);
    }
    public static int add(int a, int b){
        return a + b;
    }
}

在这里插入图片描述

值传递和引用传递

值传递

//值传递
public class Demo4 {
    public static void main(String[] args) {
        int a = 1;
        System.out.println(a);  //1
        Demo4.change(a);        //调用 change 方法
        System.out.println(a);  //1
    }
    //返回值为空
    public static void change(int a){
        a = 10;
    }
}

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

传入输出的值也是 1

引用传递

// 引用传递:传递对象，本质还是值传
public class Demo5 {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person.name); //null
        Demo5.change(person);
        System.out.println(person.name); //Muz1
    }
    public static void change(Person person){
        //person 是一个对象, 指向的是 -----> Person person = new Person();这是一个具体的人，可以改变属性
        person.name = "Muz1";
    }
}
//定义了一个 Person 类，有一个 name 属性
class Person{
    String name;
}

在这里插入图片描述

创建对象

学生类

//学生类
public class Student {
    //属性
    String name;//null
    int age;//0
    //方法
    public void study(){
        System.out.println(this.name+"在学习");
    }
}

程序类

package com.OOP.Demo2;
//一个项目只有一个 main 方法
public class Application {
    public static void main(String[] args) {
        //类: 抽象的,需要实例化
        //类实例化之后会返回一个自己的对象
        //student 对象就是 Student 类的具体实例
        Student xiaoming = new Student();
        Student xiaohong = new Student();
        
        xiaoming.name = "小明";
        xiaoming.age = 3;
        
        xiaoming.study();//小明在学习
        System.out.println(xiaoming.name);//小明
        System.out.println(xiaoming.age);//3
        
        xiaohong.name = "小红";
        xiaohong.age = 3;
        
        xiaohong.study();//小红在学习
        System.out.println(xiaohong.name);//小红
        System.out.println(xiaohong.age);//3
    }
}

在这里插入图片描述

构造器

构造器也称构造方法

//特点
1.必须和类的名字相同
2.必须没有返回类型,也不能写void

Demo

//Person.java
//java ---> class
public class Persron {
}

//Application.java
public class Application {
    public static void main(String[] args) {
        //实例化一个Persion对象,然后编译
        Persron persron = new Persron();
    }
}

实例化一个空类，然后编译输出

在这里插入图片描述

发现可以执行，但是Person类里面没有东西，然后看一下编译后生成的Person.class文件

//Person.class
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//
package com.OOP.Demo2;
public class Persron {
    public Persron() {    //自己生成Person方法
    }
}

在Person.class文件中自己生成了一个Person方法

一个类即使什么也不写，也会存在一个方法

这就是一个简单的构造器

自己定义一个构造器

public class Persron {
    //一个类即使什么也不写，也会存在一个方法
    //显示的定义构造器
    public Persron(){
     
    }
}

构造器分为无参构造器和有参构造器

Demo

//Application.java

public class Application {
    public static void main(String[] args) {
        Persron persron = new Persron();
        System.out.println(persron.name);
    }
}

//无参构造器
//Person.java

public class Persron {
    
    String name;      //定义一个name;
    //实例化初始值
    //1.使用new关键字，本质是在调用构造器
    //无参数构造
    public Persron(){
        this.name = "Mr.木Mu";
    }
}

输出

在这里插入图片描述

有参构造器

//Person.java

public class Persron {

    String name;
    //有参构造:一旦定义了有参构造,无参就必须显式定义
    public Persron(String name){
        
        this.name = name;
    }
}

这里的this.name指向就是 自己定义的 String name；
后面的name是传入的name参数

这时候的Application.java 就会有一个错误

在这里插入图片描述

在这里插入图片描述

提示我们缺少参数

为了不报错且可行，就把无参构造显式定义

//Person.java

public class Persron {
    //显示的定义构造器
    String name;
    //实例化初始值
    
    //无参数构造 显式定义
    public Persron(){

    }
    
    //有参构造:一旦定义了有参构造,无参就必须显式定义
    public Persron(String name){
        this.name = name;
    }
}

直接编译

//Application.java
public class Application {
    public static void main(String[] args) {
        //这里没有参数
        Persron persron = new Persron();
        System.out.println(persron.name);
    }
}

在这里插入图片描述

传递参数编译

public class Application {
    public static void main(String[] args) {
        //传递参数
        Persron persron = new Persron("Mr.木Mu");
        System.out.println(persron.name);
    }
}

在这里插入图片描述

简单过程:

在这里插入图片描述

在这里插入图片描述

最后输出结果
在这里插入图片描述

构造器的作用

1.使用new关键字,本质是在调用构造器
2.用来初始化值:(null,0)

//在IDEA里面的快捷键: ALT + Inster

在这里插入图片描述

完整Demo

//Application.java

//一个项目只有一个main方法
public class Application {
    public static void main(String[] args) {
        Persron persron = new Persron("Mr.木Mu");
        System.out.println(persron.name);
    }
}

//Person.java

import com.sun.jdi.event.StepEvent;
import javax.print.DocFlavor;
//java ---> class
public class Persron {
    //一个类即使什么也不写，也会存在一个方法
    //显示的定义构造器
    String name;
    //实例化初始值
    //1.使用new关键字，本质是在调用构造器
    //无参数构造
    public Persron(){
//        this.name = "Mr.木Mu";
    }
    //有参构造:一旦定义了有参构造,无参就必须显式定义
    public Persron(String name){
        this.name = name;
    }
}

/**
 *     public static void main(String[] args) {
 *         Persron persron = new Persron("Mr.木Mu");
 *         System.out.println(persron.name);
 *     }
 *
 *     @构造器:
 *          1.和类名相同
 *          2.没有返回值
 *     @作用:
 *          1.new本质 实在调用构造器
 *          2.初始化对象的值
 *     @注意点
 *          1.定义有参之后，想使用无参，显示一个定义的无参
 */

创建对象与内存分析

//Application.java

package com.OOP.Demo3;
import com.OOP.Demo2.Pet;
public class Appliacation {
    public static void main(String[] args) {
        Pet dog = new Pet();
        dog.name = "旺财";
        dog.age = 3;
        dog.shout();
        System.out.println(dog.name);
        System.out.println(dog.age);
    }
}

//Pet

package com.OOP.Demo3;
public class Pet {
    String name;
    int age;
    //无参构造
    public void shout(){
        System.out.println("叫了一声");
    }
}

在这里插入图片描述

封装

//Application.java

package com.OOP.Demo4;
/**
 * 1.提高程序安全性
 * 2.隐藏代码的实现细节
 * 3.统一接口
 * 4.增加系统的可维护性
 */
public class Application {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.getName();
        String name = s1.getName();
        s1.setName("Muz1");
        System.out.println(s1.getName());
        s1.setAge(999);
        System.out.println(s1.getAge());
    }
}

//Student.java

package com.OOP.Demo4;
//类     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 getAge() {
        return age;
    }
    public void setAge(int age) {
        if(age>120 || age<0){
            this.age = 3;
        }else {
            this.age = age;
        }
    }
}

在这里插入图片描述

继承

//Application

package com.OOP.Demo5;
public class Application {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.say();
        System.out.println(s1.money);
    }
}

//Person

package com.OOP.Demo5;
//人 : 父类
public class Person {
    //public
    public int money = 1000000;
    public void say(){
        System.out.println("啊吧啊吧");
    }

}

Student类 里面没有内容

//Student

package com.OOP.Demo5;
//Student is 人 ： 子类
public class Student extends Person{
}

在这里插入图片描述

把 pubilc 换成 private

package com.OOP.Demo5;
//人 : 父类
public class Person {

    //private
    private int money = 1000000;
    public void say(){
        System.out.println("啊吧啊吧");
    }
}

报错显示

在这里插入图片描述

在这里插入图片描述

添加 getter/setter

//Person

package com.OOP.Demo5;
//人 : 父类
public class Person {
    //public
    //prvate
    //default
    //protected
    private int money = 1000000;
    public void say(){
        System.out.println("啊吧啊吧");
    }
    public int getMoney() {
        return money;
    }
    public void setMoney(int money) {
        this.money = money;
    }
}

ctrl+H

在这里插入图片描述

把 Person 类 清空

package com.OOP.Demo5;
//人 : 父类
public class Person {
    
}

在这里插入图片描述

可以看到有好多的方法

实际上都是Object类中的方法

在这里插入图片描述

在这里插入图片描述

每个类都有Object类

Java只有单继承

super

super用于调用父类变量

//Application
package com.OOP.Demo5;
public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        student.test("Application");
    }
}

//Person
package com.OOP.Demo5;
//人 : 父类
public class Person {
    protected String name = "Person";
}

//Student
package com.OOP.Demo5;
//Student is 人 ： 子类
public class Student extends Person{
    private String name = "Student";
    public void test(String name){
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.name);
    }
}

执行Application.java输出

在这里插入图片描述

//test()
public void test(String name){
    System.out.println(name);      //Application
    System.out.println(this.name); //Student
    System.out.println(super.name);//Person
}

修改函数

//Application
public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        student.test1();
    }
}

//Person
package com.OOP.Demo5;
//人 : 父类
public class Person {
    public void print(){
        System.out.println("Person");
    }
}

//Student
package com.OOP.Demo5;
//Student is 人 ： 子类
public class Student extends Person{

    public void print(){
        System.out.println("Student");
    }
    public void test1(){
        print();
        this.print();
        super.print();
    }
}

输出结果

在这里插入图片描述

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

构造器

//Application
public class Application {
    public static void main(String[] args) {
        Student student = new Student();
    }
}

//Person
public class Person {
    public Person() {
        System.out.println("Person无参构造执行了");
    }
}

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

在这里插入图片描述

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

方法的重写

//Application
public class Application {
    public static void main(String[] args) {
        A a = new A();
        a.test();
    }
}

//A
public class A extends B{
    public static void test(){
        System.out.println("A=>test()");
    }
}

//B
//重写都是方法的重写
public class B {
    public static void test(){
        System.out.println("B=>test()");
    }
}

输出
在这里插入图片描述

在Application.java 中加入

public class Application {
    public static void main(String[] args) {
        A a = new A();
        a.test();   //A
        //父类的引用指向了子类
        B b = new A();
        b.test();   //B
    }
}

运行

在这里插入图片描述

把 static 去掉

在这里插入图片描述
再次运行得到

在这里插入图片描述

即b是A new出来的对象，因此调用了A的方法
因为静态方法是类的方法，而非静态是对象的方法
有static时，b调用了B类的方法，因为b是用b类定义的
没有static时，b调用的是对象的方法，而b是用A类new的

/**
 * 重写：需要有继承关系，子类重写父类的方法
 * 1。方法名必须相同
 * 2.参数列表必须胸痛
 * 3.修饰符: 范围可以扩大 pulic > protected > default > private
 * 4.抛出的异常 : 可以被缩小，但不能扩大: ClassNotFound ----> Exception
 */
木拖把
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java教程：一文搞懂hashmap是否线程安全
CZ-001的博客
08-26 501
通过上面的学习得知，hashmap在多线程情况下初始化数组和扩容的时候均会出现线程安全问题。我们可以通过HashTable来解决，HashTable是对整个hash表加锁，相当于线程串行化操作hash表，在解决问题的同时也会导致性能极低。最终我们可以使用ConcurrentHashMap将锁的粒度控制到最小，将性能影响控制到最低，同时扩容的时候ConcurrentHashMap还支持多线程扩容。...
Java面向对象学习笔记（二）
u010171051的博客
04-12 179
二、面向对象--2 （一）深入变量 128、变量的分类-作用域-初始值 定义变量的语法格式：数据类型 变量名 = 值; 定义位置不同，分为： 成员变量：全局变量/字段（field），不要称为属性，直接定义在类中，方法外面。分为： 1)类成员变量：使用static修饰的字段 2)实例成员变量：没有使用static修饰的字段 局部变量：变量除了成员变量，其他的都是 局部变量 1)方法内部的变量 ...
Java 数组的学习
Lynnand的博客
10-25 156
理解数组作用：数组本身是一个变量，存储相同数据类型的一组数据 声明一个变量: 内存空间划出一块合适的空间 声明一个数组: 内存空间划出一串连续的空间 数组基本要素: 标识符——数组名 数组元素——值（必须属于相同的数据类型)数数组中的所有元素必须属于相同的数据类型组中的所素必须属于相同的 元素类型——类型 元素下标——从0开始（即索引，目录的概念） 数组地址——数组本身的值 数组长度固定不变，避免数组越界 声声明一个变量就是在内存空间划出一块合适的空间 声明一个数组就是在内存空间.
javademo2
Gona_Shrimp的博客
04-06 333
1：下列哪个答案与show不是方法重载( B )。 class Demo {          void show(int a,int b,float c){} } A.void show(inta,float c,int b){} B,void show(int x,inty,float z){} C.int show(int a,floatc,int b){return a;
Java基础（十五）专题课-编程案例
Léon
05-27 565
十五、专题课-编程案例 目的： 复习前半段课程学习的Java编程知识，能够使用所学的知识解决问题，提升编程能力。 涉及到的知识点： 变量、数组 运算符：基本运算符、关系运算符、逻辑运算符… 程序流程控制：if、switch; for、while; 死循环、循环嵌套 跳转关键字：break、continue、return 方法 编程思维： 使用所学的Java技术解决问题的思维方法和编写代码实现出来的能力。 关于提升编程思维和编程能力的建议 编程思维和编程能力不是一朝一夕形成的，需要时间的沉淀和大
Java基础类库
m0_52596096的博客
03-04 671
StringBuffer类 作用：实现字符串内容的修改 构造方法：public StringBuffer() 构造方法：public StringBuffer(String str),可以接受字符串初始化内容 数据追加：public StringBuffer append(数据类型 变量)，相当于字符串中的“+”操作 public class Demo { public static void main(String[] args) { StringBuffer buf = ne
Java——面向对象（1）
Stargazer（仰望星空）的博客
07-20 134
文章目录1、面向对象基本概念2、类与对象3、类和对象的定义格式4、对象与内存分析5、封装性6、构造方法7、this关键字 1、面向对象基本概念 其本质是以建立模型体现出来的抽象思维过程和面向对象的方法（百度百科） 是一种编程思维，也是一种思考问题的方式 如何建立面向对象的思维呢？ 先整体，再局部 先抽象，再具体 能做什么，再怎么做 2、类与对象 类：类是一种分类，一个类别，一个模板，它描述一类对象的行为和状态，是一组具有相同特性（属性）与行为（方法）的事物集合 对象：是一个个性的产物，是一个个体的特征，
Java学习笔记-面向对象-001-面向对象概括
06-05
同时，阅读优秀的Java学习笔记和参考书籍，参与在线社区和论坛讨论，都可以帮助你加快学习进度，提高编程技能。在Java的世界里，不断探索和实践，你将能够构建出高效、可靠的面向对象软件系统。
Java面向对象编程学习笔记.pdf
12-01
"Java面向对象编程学习笔记.pdf" Java面向对象编程学习笔记是Java程序设计语言中面向对象编程（Object-Oriented Programming，OOP）的一份学习笔记。面向对象编程是一种软件设计方法，它强调使用对象和类来模拟现实...
Java学习笔记之面向对象基本概念
12-22
　面向对象程序设计是将人们认识世界过程中普遍采用的思维方法应用到程序设计中。 　对象是现实世界中存在的事物，它们是有形的，如某个人、某种物品;也可以是无形的，如某项计划、某次商业交易。 　对象是构成...
java学习笔记（面向对象）
03-07
通过不断练习和学习，可以更好地利用Java的面向对象特性来解决各种复杂问题。对于初学者来说，可以参考书籍、在线教程或实际项目来深入学习这些知识。同时，刷LeetCode等平台的题目，可以帮助巩固理论知识并提高编程...
Java学习笔记，面向对象深化
02-06
【Java面向对象深化】知识点详解 面向对象编程是Java的核心特性之一，它通过类和对象的概念，模拟现实世界中的实体，使代码更加模块化和可维护。以下将深入讲解Java中面向对象的一些关键知识点。 1. **继承**： -...
《Java系列-学习相关》Java详细入门教程
https://blog.datasource.space
04-05 321
任何给java取名称的都叫做标识符栈内存：Stack，连续的内存空间，先进后出，主要存放局部变量堆内存：Heap，不连续的内存空间，存放对象，对象的实例。new出来的都放在这里方法区（Method），其实他是在堆空间之内，存放类的信息，静态的变量和方法，常量池。
day046：时间日期类:Date
ZuoQi的博客
05-12 249
一、注： 世界标准时间：原子钟 北京时间需要在世界标准时间上加8小时 1秒=1000毫秒 计算机中的时间原点（即起始时间）为1970年1月1日00：00：00 二、Date类概述和构造方法 1.Date代表一个精确的时间，精确到毫秒 2.构造方法： public Date() 创建一个Date对象，表示默认时间（即计算机的当前时间） public Date(long time) 创建一个Date对象，表示指定时间 代码示例： import java.util.D...
java周测题（1）
qq_45111873的博客
07-19 564
一个数如果恰好等于它的因子之和，这个数就称为 "完数 "。例如6=1＋2＋3 编程找出1000以内的所有完数。 public class Demo1 { public static void main(String[] args) { //求1000以内的所有完数 int sum=0; //统计完数个数 for(int i=1;i<=1000;i++) { int x=0; .
第七章 数组/方法传参
LLLlucky_boy的博客
07-18 392
Java基础入门06第七章 数组/方法传参7.1 数组定义和访问7.1.1 容器概述案例分析容器概念7.1.2 数组概念7.1.3 数组的定义7.1.4 数组的初始化方式一方式二方式三7.1.5 数组的访问7.2 数组原理内存图7.2.1 内存概述7.2.2 Java虚拟机的内存划分7.2.3 数组在内存中的存储一个数组内存图两个数组内存图两个变量指向一个数组7.3 数组操作的常见问题7.3.1 数组越界异常7.3.2 数组空指针异常7.4 数组练习7.4.1 数组遍历【重点】7.4.2 数组获取最大
class Demo2
小叶子的博客
11-09 781
public class Demo2 {     public static void main(String[] args){         //函数重载演示2         add(1, 3.0);         add(1, 2);     }     public static double add(int a, int b){         System.out.println...
public class Demo02<T> implements IStoreAsList<T>
autumn20080101的专栏
11-05 588
import java.util.List; public interface IStoreAsList {  List store(M[] arr); } import java.util.ArrayList; import java.util.Arrays; import java.util.List; public class Demo02 implem
Elsaticsearch java基本操作
最新发布
qq_62383709的博客
07-13 479
索引 基本操作 package com.orchids.elasticsearch.web.controller; import cn.hutool.core.collection.CollUtil; import cn.hutool.json.JSONUtil; import com.orchids.elasticsearch.web.po.User; import io.swagger.annotations.Api; import io.swagger.annotations.ApiOperatio
JavaSE笔记11111
10-15
JavaSE笔记涵盖 面向对象的三大特征:继承,多态,封装 单列集合与双列集合:collection & map IO流:InputStream字节输入流,OutputStream字节输出流,Reader字符输入流,Writer字符输出流; 多线程&线程池; 反射&动态代理等

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值