3.27总结

一、每日一题

350. 两个数组的交集 II - 力扣（LeetCode） (leetcode-cn.com)

思路：利用双指针，因为不考虑输出顺序，所以先将数组排序，然后用两个指针先指向两个数组的开始，然后两个指针所指的值不同时就把指到小的指针往后一位，如果相等就先记录下这个值，然后两个指针都往后移动，直到有个指针到了最后。

代码实现

class Solution {
    public int[] intersect(int[] nums1, int[] nums2) {
        Arrays.sort(nums1);//先进行排序
        Arrays.sort(nums2);
        int i=0,j=0,k=0;
        int [] arr1=new int[nums1.length];//创建一个新数组来存相同的数字
        while(i<nums1.length&&j<nums2.length)
        {
            if(nums1[i]<nums2[j])//哪个数组小就往后移
            {
                i++;
            }
            else if(nums1[i]>nums2[j])
            {
                j++;
            }
            else//相等就存下来
            {
                arr1[k]=nums1[i];
                k++;
                i++;
                j++;
            }
        }
        int [] arr2=new int[k];//因为相同的长度只会等于或小于，所以后面可能会有数组初始化的0
        for(i=0;i<k;i++)//把数组初始化的0全部去掉
        {
            arr2[i]=arr1[i];
        }
        return arr2;
    }
}

过题记录

 

二、Java学习

1.static

static是一个关键字，它真正的作用是用于区分成员变量、方法、内部类、初始化块这四种成员到底是属于类本身还是实例。在类中定义的成员，有static修饰的属于类本身，没有static修饰的属于实例。

2.构造器

构造器通常也叫构造方法、构造函数，构造器在每个项目中几乎无处不在。当你new一个对象时，就会调用构造器。构造器格式如下：

[修饰符，比如public] 类名 (参数列表，可以没有参数){
	//不能有return
}

默认构造器： 新建一个类，不提供任何构造器，编译器会默认提供一个无参构造器，这就是为什么没定义任何构造器，却可以new 某个对象()

public class People {
    
}

 我的实践

public class SxStu {
    //属性
    int id;
    String name;
    int age;
    //方法
    void study(){
        System.out.println("我正在奋斗!!!");
    }
    //构造器(方法名和类名相同)
    SxStu(int id,String name,int age){
        this.id=id;
        this.name=name;
        this.age=age;
    }
    public static void main(String[] args){
        SxStu s1=new SxStu(1019,"李现",31);
        System.out.println(s1.id);
        System.out.println(s1.name);
        System.out.println(s1.age);
        /*s1.id=1019;
        s1.name="李现";
        s1.age=31;*/
        System.out.println(s1.id);
        System.out.println(s1.name);
        System.out.println(s1.age);
        s1.study();
        System.out.println("=============");
        SxStu s2=new SxStu(1991,"陆珊",17);
        s2.id=1991;
        s2.name="陆珊";
        s2.age=17;
        System.out.println(s2.id);
        System.out.println(s2.name);
        System.out.println(s2.age);
        s2.study();
    }
}

class Point{//求两点之间的距离
    double x,y;
    public Point(double _x,double _y)
    {
        x=_x;
        y=_y;
    }
    public double getDistance(Point p)
    {
        return Math.sqrt((x-p.x)*(x-p.x)+(y-p.y)*(y-p.y));
    }
}
public class TestConstructor {
    public static void main(String[] args){
        Point p=new Point(3.0,4.0);
        Point origin=new Point(0.0,0.0);
        System.out.println(p.getDistance(origin));
    }
}

3.类是一个引用数据类型，它被存放在栈里，指向实际的对象；而真正的对象存在堆内存里。实际上，Java里的引用就是C里面的指针，引用变量和指针一样，它们都是存储一个地址值，只是Java将这些指针封装起来，用着更加方便。

class Person{
    String name;
    int age;
    public void show(){
        System.out.println("姓名："+name+",年龄："+age);
    }
}
public class TestPerson {
    public static void main(String[] args){
        Person p1=new Person();
        p1.age=17;
        p1.name="陆珊";
        p1.show();
        Person p2=new Person();
        p2.age=31;
        p2.name="李现";
        p2.show();
    }
}

3.类里面的方法相互调用

public class Dog {
    //定义一个jump方法
    public void jump()
    {
        System.out.println("正在执行jump方法");
    }
    //定义一个run方法，run方法需要借助jump方法
    public void run()
    {
        Dog d=new Dog();//没有使用static修饰的成员变量和方法都必须使用对象调用
        d.jump();
        System.out.println("正在执行run方法");
    }
    public static void main(String[] args)
    {
        Dog dog=new Dog();
        //dog.jump();
        dog.run();
    }
}

  

4.this

通过this关键字可以明确的访问一个类的成员变量，解决成员变量与局部变量名称冲突问题。

public class Student {
   //定义四个成员变量
   String name;
   int age;
   long phone;
   String address;
   //有参构造方法
   public Student(String name, int age, long phone, String address) {
        this.name = name;
        this.age = age;
        this.phone = phone;
        this.address = address;
    }
   //成员变量的get/set方法
   public String getName(){
       //访问的是成员变量name
       return this.name;
   }
   
   public void setName(String name) {
        this.name = name;
    }
}

通过this关键字调用成员方法(与第三点里面的代码稍有不同)

public class Dog {
    //定义一个jump方法
    public void jump()
    {
        System.out.println("正在执行jump方法");
    }
    //定义一个run方法，run方法需要借助jump方法
    public void run()
    {
        this.jump();
        Dog d=new Dog();//没有使用static修饰的成员变量和方法都必须使用对象调用
        d.jump();
        System.out.println("正在执行run方法");
    }
    public static void main(String[] args)
    {
        Dog dog=new Dog();
        //dog.jump();
        dog.run();
    }
}

 Java允许对象的一个成员直接调用另一个成员，可以省略this前缀，上面的代码可以稍作修改。

public class Dog {
    //定义一个jump方法
    public void jump()
    {
        System.out.println("正在执行jump方法");
    }
    //定义一个run方法，run方法需要借助jump方法
    public void run()
    {
        //this.jump();
        jump();
        Dog d=new Dog();//没有使用static修饰的成员变量和方法都必须使用对象调用
        d.jump();
        System.out.println("正在执行run方法");
    }
    public static void main(String[] args)
    {
        Dog dog=new Dog();
        //dog.jump();
        dog.run();
    }
}

注意：对于static修饰的方法可以直接通过类来调用，，如果在static修饰的方法使用this关键字，则这个关键字就无法指向正确的对象，所以static修饰的方法不能用this引用。由于static修饰的方法不能用this引用，所以static不能不能访问不用static修饰的成员，因此有如下规定：静态成员变量不能直接访问非静态成员变量。

Java中调用static修饰的成员变量、方法应该使用类，而不是对象。

5.基本类型的参数传递

下面的例子中，main方法里的参数没有变，变化的是swap方法里面的参数

首先，程序从main方法开始执行，给main方法里面的参数传递值。

然后通过main方法给swap方法里面传形参

 

 最后在swap栈区进行交换

public class PrimitiveTransferTest {
    public static void swap(int a,int b)
    {
        int t=a;
        a=b;
        b=t;
        System.out.println("swap方法里，a的值是："+a+";b的值是"+b);
    }
    public static void main(String[] args)
    {
        int a=1019;
        int b=1991;
        swap(a,b);
        System.out.println("交换后的，变量a的值是"+a+";变量b的值是"+b);//main方法栈区的a和b没有变
    }
}

 6.引用类型的参数传递

程序从main()方法开始，main()方法里面创建了一个DataWrap对象，然后定义了一个dw引用变量来指向DataWrap对象，这里与基本类型的参数传递有区别。创建对象时，堆内存保存了对象本身，栈内存保存了引用该对象的引用变量。接下来就是给DataWrap赋值，再调用swap方法，通过参数传递，给swap方法里的变量赋值。其实main方法和swap方法都只是保存了Datawrap的地址值，所以swap方法操作的就是DataWrap对象，两者都是保存DataWrap的地址，引用的是同一个对象，所以swap方法将值交换后，main方法里面的值也发生了交换。

class DataWrap
{
    int a;
    int b;
}
public class ReferenceTransferTest {
    public static void swap(DataWrap dw)
    {
        int t=dw.a;
        dw.a=dw.b;
        dw.b=t;
        System.out.println("swap方法里，a成员变量的值是"+dw.a+";b成员变量的值是"+dw.b);
        dw=null;
    }
    public static void main(String[] args)
    {
        DataWrap dw=new DataWrap();
        dw.a=6;
        dw.b=9;
        swap(dw);
        System.out.println("交换结束后，a的值为："+dw.a+";b的值为："+dw.b);
    }
}

 7.方法重载

同一个类中方法的名称相等，形参列表不同，其他随便。

public class Overload {
    public void test()
    {
        System.out.println("我是第一个test方法，无参数");
    }
    public void test(String msg)
    {
        System.out.println("我是第二个test方法，"+msg);
    }
    public static void main(String[] args)
    {
        Overload ol=new Overload();
        ol.test();
        ol.test("hello");
    }
}

8.变量：成员变量和局部变量

class Personn
{
    public String name;
    public static int eyeNum;
}
public class PersonTest {
    public static void main(String[] args)
    {
        System.out.println("Person的eyeNum类的变量值："+Personn.eyeNum);
        Personn p=new Personn();
        System.out.println("p变量的name变量值是："+p.name+"p对象的eyeNum变量值是：："+p.eyeNum);
        p.name="孙悟空";
        p.eyeNum=2;
        System.out.println("p变量的name变量值："+p.name+"p对象的eyeNum变量值为："+p.eyeNum);
        System.out.println("Person的eyeNum类变量值："+Personn.eyeNum);
        Personn p2=new Personn();
        System.out.println("p2对象的eyeNum类变量值："+p2.eyeNum);
        System.out.println("p2对象的eyeNum类变量值："+Personn.eyeNum);
    }
}

9. 变量命名规则

一个类里面不能定义两个同名的成员变量，即使一个是类变量，一个是实例变量也不行。

一个方法里面不能定义两个同名的方法局部变量，方法局部变量也不能与形参名相同。

同一个方法里面不同的代码块内的代码块局部变量可以相同。

如果先定义代码块局部变量，后定义方法局部变量，则前面的代码块变量可以和后面的方法局部变量相同。

局部变量可以和成员变量相同，局部变量会覆盖成员变量，如果要引用该成员变量，则要通过添加前缀this(对于实例变量)或者类名(对于类变量)。

10，局部变量保存的是值或者是地址值

如果局部变量是基本数据类型，则直接保存基本数据类型的值。如果局部变量是引用数据类型，则保存的是地址值，通过地址值引用到该变量实际引用的数组或对象。