学习笔记# - 技术栈

一基础相关知识点：

1. 一个对象的调用

首先我们创建一个Phone类

java 复制代码

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类我们创建一个对象。再访问成员变量，调用成员方法。

java 复制代码

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类：

java 复制代码

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);
    }
}

具体代码调用：

java 复制代码

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 类的创建：

java 复制代码

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);
    }
}

具体的代码调用：

java 复制代码

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. 使用对象类型作为方法的参数：

普通的方法调用：

java 复制代码

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);
    }
}

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

java 复制代码

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类

java 复制代码

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);
    }
}

具体调用：

java 复制代码

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.方法的封装

java 复制代码

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 类的创建：

java 复制代码

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类的调用：

java 复制代码

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.

java 复制代码

public class helloax {
    String name;
    int age;

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

    }

}

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

java 复制代码

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.编写一个全参数的构造方法

实例展示：

java 复制代码

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;
    }
}

具体调用：

java 复制代码

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());

    }
}