学习笔记#

于 2024-08-26 20:06:02 发布
阅读量499 收藏 9
点赞数 8
文章标签： java 前端 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2302_79847831/article/details/141572243
版权

 一基础相关知识点：

1. 一个对象的调用

首先我们创建一个Phone类

public class Phone {
    //成员变量
    String name;
    int age;
    String favourite;


    //成员方法
    public void myName(){
        System.out.println(name);
    }

    public void myAge(){
        System.out.println(age);
    }

    public void myFavourite(){
        System.out.println(favourite);
    }
}

根据Phone类我们创建一个对象。再访问成员变量，调用成员方法。

public class usingPhone {
    public static void main(String [] args){

        //创建对象
        Phone P = new Phone();
        
        //访问成员变量
        P.age = 19;
        P.name = "ax";
        P.favourite = "eat";
        System.out.println(P.age+" "+P.name+" "+P.favourite);
        
        //调用成员方法
        P.myAge();
        P.myName();
        P.myFavourite();
    }
}

执行结果：

内存图分析

2. 两个对象使用一个方法：

创建Phone类：

public class Phone {
    //成员变量
    String name;
    int age;
    String favourite;


    //成员方法
    public void myName(){
        System.out.println(name);
    }

    public void myAge(){
        System.out.println(age);
    }

    public void myFavourite(){
        System.out.println(favourite);
    }
}

具体代码调用：

public class usingPhone {
    public static void main(String [] args){

        //创建对象
        Phone P = new Phone();

        //访问成员变量
        P.age = 19;
        P.name = "ax";
        P.favourite = "eat";
        System.out.println(P.age+" "+P.name+" "+P.favourite);

        //调用成员方法
        P.myAge();
        P.myName();
        P.myFavourite();

        //创建对象
        Phone Q = new Phone();

        //访问成员变量
        Q.age = 191;
        Q.name = "ax1";
        Q.favourite = "eat1";
        System.out.println(Q.age+" "+Q.name+" "+Q.favourite);

        //调用成员方法
        Q.myAge();
        Q.myName();
        Q.myFavourite();
    }
}

内存图：

3. 两个引用指向同一个对象：

Phone 类的创建：

public class Phone {
    //成员变量
    String name;
    int age;
    String favourite;


    //成员方法
    public void myName(){
        System.out.println(name);
    }

    public void myAge(){
        System.out.println(age);
    }

    public void myFavourite(){
        System.out.println(favourite);
    }
}

具体的代码调用：

public class usingPhone {
    public static void main(String [] args) {

        //创建对象
        Phone P = new Phone();

        //访问成员变量
        P.age = 19;
        P.name = "ax";
        P.favourite = "eat";
        System.out.println(P.age + " " + P.name + " " + P.favourite);

        //调用成员方法
        P.myAge();
        P.myName();
        P.myFavourite();

        Phone Q = P;
        System.out.println(Q.age + " " + Q.name + " " + Q.favourite);

    }
}

内存图：

4. 使用对象类型作为方法的参数：

普通的方法调用：

public class usingPhone {
    public static void main(String [] args) {

        //创建对象
        Phone P = new Phone();

        //访问成员变量
        P.age = 19;
        P.name = "ax";
        P.favourite = "eat";
        System.out.println(P.age + " " + P.name + " " + P.favourite);

        //调用成员方法
        P.myAge();
        P.myName();
        P.myFavourite();
        //方法调用
        define(100);
    }
    public static void define(int num){
        System.out.println(num);
    }
}

使用对象类型作为方法的参数：

public class usingPhone {
    public static void main(String [] args) {

        //创建对象
        Phone P = new Phone();

        //访问成员变量
        P.age = 19;
        P.name = "ax";
        P.favourite = "eat";
        System.out.println(P.age + " " + P.name + " " + P.favourite);

        //调用成员方法
        P.myAge();
        P.myName();
        P.myFavourite();
        //方法调用
        define(P);//等同于Phone ax = P;
    }
    public static void define(Phone ax){
        System.out.println("m"+"\t"+ ax.age);
    }
}

内存图：

5. 使用对象类型作为方法的返回值：

Phone类

public class Phone {
    //成员变量
    String name;
    int age;
    String favourite;


    //成员方法
    public void myName(){
        System.out.println(name);
    }

    public void myAge(int age){
        System.out.println(age);
    }

    public void myFavourite(){
        System.out.println(favourite);
    }
}

具体调用：

public class usingPhone {
    public static void main(String [] args) {

        //创建对象
        Phone P = new Phone();

        //访问成员变量
        P.age = 19;
        P.name = "ax";
        P.favourite = "eat";
        System.out.println(P.age + " " + P.name + " " + P.favourite);

        //调用成员方法
        P.myAge(19);
        P.myName();
        P.myFavourite();
        
        Phone Q = define();
        System.out.println(Q.age + " \n" + Q.name + "\n" + Q.favourite);
    }
    public static Phone define(){
        Phone Def = new Phone();
        Def.age = 18;
        Def.myAge(200);
        return Def;
    }
}

内存图：

二.成员（全局）变量与局部变量：

两者的区别：

1.定义的位置不一样

局部变量：在方法的内部。

成员变量：在方法的外部，直接写在类中。

============================================

2.作用范围不一样

局部变量：只有方法当中才可以使用，除了方法就不能再用。

成员变量：整个类中都可以使用。

=============================================

3.默认值不一样

局部变量：没有默认值，如果想使用，必须手动赋值。

成员变量：如果没有赋值，会有默认值，规则与数组的相同。

=============================================

4.内存的位置不一样

三.面向对象的步步实现

封装：将一些细节信息隐藏，直接调用即可。

1.方法就是一种封装

2.private也是一种封装

1.方法的封装

public class an7 {
    public static void main(String[] args) {
        int[] arr = {12,22,23,42,52,26,72,82,39};
        int max1 = methodmax(arr);
        System.out.println(max1);

    }
    public static int methodmax(int[] arr){
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i]>max){
                max= arr[i];
            }
        }
        return max;

    }
}

运行结果：

2 private关键字

    写了private在本类中的访问可以正常使用，在其他类的调用不可以直接访问，


    我们使用间接访问的方法，setter,getter.(boolean是setter与is--)


    setter不能有返回值，用于传递参数值.


    getter不能有参数，用于返回成员变量.

something 类的创建：

public class something {

    String name;
    private int age;

    public void show(){
        System.out.println("Name: "+name+"\t"+age);
    }

    public void setAge(int Newage){
        age=Newage;
    }

    public int getAge(){
        return age;
    }

}

something类的调用：

public class usingsomething{
    public static void main(String[] args) {
        something Something = new something();

        Something.name="ax";

        Something.setAge(20);

        Something.show();
        
    }

}

3 this关键字（this要写在方法内）

这种情况下的name均为参数name,而不是成员变量name.

public class helloax {
    String name;
    int age;

    public void Name(String name) {
        System.out.println(name+"你好"+name);

    }

}

如果想以此区分两个name，可以使用关键字this.~

public class helloax {
    String name;
    int age;

    public void Name(String name) {
        System.out.println(name+"你好"+this.name);

    }

}

4 定义一个标准的类：(java bean)

一个标准类的满足下列条件：

1.所有的成员变量都要使用private修饰

2.对每一个成员变量编写一对getter,setter方法用于初始化

3.编写一个无参数的构造方法

4.编写一个全参数的构造方法

实例展示：

public class student {
    private String name;
    private int age;
    private String genter;

    public student(String name, int age, String genter) {
        this.name = name;
        this.age = age;
        this.genter = genter;
    }

    public student() {
    }

    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 getGenter() {
        return genter;
    }

    public void setGenter(String genter) {
        this.genter = genter;
    }
}

具体调用：

public class usingstudent {
    public static void main(String[] args){
        student P = new student();
        P.setAge(19);
        P.setName("anxian");
        P.setGenter("nan");
        System.out.println("姓名"+P.getName()+"\t"+"年龄"+P.getAge()+"\t"+"性别"+P.getGenter());

        System.out.println("===============================");

        student Q =new student("anxian",19,"nan");
        System.out.println("姓名"+Q.getName()+"\t"+"年龄"+Q.getGenter()+"\t"+"性别"+Q.getGenter());

    }
}

小安同学iter
关注
  • 8
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
##matlab学习笔记##.md
06-03
matlab学习笔记
java学习笔记总结
04-02
这份“java学习笔记总结”涵盖了作者在深入学习Java过程中积累的知识点和实践经验，旨在帮助读者理解和掌握Java的核心概念。 首先，Java的基础部分包括语法、变量、数据类型、运算符和流程控制。Java支持八种基本...
Python学习笔记#001-在Window系统中从终端运行Python程序
fwl19901123的博客
04-15 1454
Python学习笔记#001-在Window系统中从终端运行Python程序
#tensorflow学习笔记#tf.gather
Mr48694869的博客
04-16 3642
根据tensorflow API1.0可以看出，tf.gather用于获取tensor中某几位的量 以下是测试结果 输出的时候出错了 主要原因是sess = tf.Session()中没有加括号
MATLAB学习笔记#003 数值转字符
littzhi的博客
11-29 1532
【代码】MATLAB学习笔记#003 数值转字符。
#学习笔记#base标签的作用
AHua~
06-16 1万+
base标签 base标签可以设置当前页面中所有相对路径工作时，参照哪个路径进行跳转 在进行请求转发时会改变页面的相对路径，我们可以通过base标签来锁定页面工作路径，来做到请求转发时不会应为相对路径的改变出错 这里演示一个普通页面跳转中如何做到锁定工作相对路径 相关代码： <!--base标签.html--> <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8">
#学习笔记#09_对象数组
AHua~
07-28 1万+
对象数组 基本使用 //a13_对象数组.java public class a13_对象数组 { public static void main(String[] args) { // 定义一个数组，存储3个Person对象 a13_对象数组01[] array01 = new a13_对象数组01[3]; System.out.println(array01[0]); System.out.println("----------");
#学习笔记#Servlet的生命周期
AHua~
05-27 1万+
Servlet的生命周期(从创建到销毁的过程) 1.执行Servlet构造器方法(第一次访问的时候创建Servlet程序会调用) 2.执行init初始化方法(第一次访问的时候创建Servlet程序会调用) 3.执行service方法(每次访问都会调用) 4.执行destroy方法(在Web工程停止的时候调用) 示例代码： //HelloServlet.java package servlet; import javax.servlet.*; import java.io.IOException; p
#学习笔记#JavaEE的三层架构
AHua~
06-19 1万+
JavaEE的三层架构 1、JavaEE架构图
#学习笔记#如何部署Web工程到Tomcat中
热门推荐
AHua~
05-26 2万+
如何部署Web工程部署到Tomcat 第一种： 1.将web工程目录拷贝到Tomcat的webapps目录 2.浏览器输入地址http://localhost:8080/(webapps的文件) 第二种： 1.在Tomcatde中conf/Catalina/localhost 新建xml配置文件 <!-- xml配置文件模板： --> <!-- Context表示一个工程上下文 path表示工程访问路径 docBase表示你的工程目录在哪里 --> <Cont
#tensorflow学习笔记#tf.contrib.framework.get_or_create_global_step
Mr48694869的博客
04-12 8689
建立全局变量 代码参考 self.global_step = tf.contrib.framework.get_or_create_global_step()
Qt学习笔记#5：QTransform
founderznd
05-29 1万+
QTransform类QTransform类用于控制二维坐标系之间的转换包含：位移、缩放、扭曲、旋转还有映射首先看它的核心内容：这是一个仿射变换矩阵(affine transformation)，它包含了坐标系转换所需要的所有信息 element description m11 水平缩放 m22 垂直缩放 m21 水平扭曲 m12 垂直扭曲 m31(dx)
教师资格证-幼儿园【综合素质】学习笔记#..pdf
11-10
教师资格证-幼儿园【综合素质】学习笔记#..pdf
教师资格证幼儿园【综合素质】学习笔记#精选...pdf
12-01
教师资格证幼儿园【综合素质】学习笔记#精选...pdf
学习笔记学习笔记学习笔记
01-29
学习笔记学习笔记学习笔记
开发多线程程序时，需要注意那些问题
最新发布
OO_SEN的博客
08-23 555
线程安全 竞态条件（Race Condition）：当多个线程同时访问和修改共享资源时，可能会出现竞态条件，导致不确定的行为。需要通过同步机制（如互斥锁、读写锁、原子操作）来保护共享资源。 死锁（Deadlock）：当两个或多个线程相互等待对方释放锁时，程序会陷入死锁状态。避免死锁的一些策略包括：避免嵌套锁、确保加锁顺序一致、使用超时机制等。 活锁（Livelock）：与死锁不同，活锁是指线程不断地尝试获取资源但总是失败，导致无法继续执行。避免频繁重试操作或使用退避算法可以减少活锁的发生。 优先级反转（P
Yolov8：模型部署到安卓端
m0_70694811的博客
08-21 795
下载安装jdk-8u202-windows-x64.exe，这篇文章有百度网盘资源链接，直接下载，并按照这篇文章的JDK步骤进行安装和环境变量配置。C:\Program Files\Java\jdk-1.8\bin和C:\Program Files\Java\jdk-1.8\jre\bin。比如因为我的jdk路径是C:\Program Files\Java\jdk-1.8，所以这两个相对路径就改成。参考这边文章的USB驱动设置和手机端设置。同意协议后，下载相应版本的JDK。
笔记redis
风止的博客
08-22 1081
Redis（Remote Dictionary Server）是用C语言开发的一个基于的数据库。
@Transactional中使用线程锁导致了锁失效与解决方案
liuruiaaa的博客
08-23 770
@Transactional中使用线程锁导致了锁失效与解决方案
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值