Java教程

Java学习【Day 6】

本文主要是介绍Java学习【Day 6】,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

文章目录

        • import导入、Scanner类
        • 访问权限
        • Object类的toString()
        • Object类的equals()
        • String类的equals、toString方法
        • 何时用 == 或 equals比较相等?
        • equals()方法的又一个例子
        • Object类的finalize() 垃圾回收
        • 内部类
        • 匿名内部类
        • 数组
        • 数组作为方法的参数时
        • main方法的参数:`String[] args`
        • 数组拷贝

import导入、Scanner类

使用的两个类不在同一包下,则需要import导入

lang目录下的子类(子文件夹不算)都不需要导入
比如System类和String类

import java.util.Scanner;	//导入Scanner类

public class KeyInput {
    public static void main(String[] args){
        //Scanner s = new Scanner(System.in);//等待输入
        java.util.Scanner s = new java.util.Scanner(System.in);//等待输入
        //  java.util.Scanner s =
        String str = s.next();//接收一个str类型
        int i = s.nextInt();//接收一个int类型
        System.out.println("你输入的String是:"+str);
        System.out.println("你输入的int是:"+i);

    }
}

访问权限

public 		公开的						任何位置都可访问
private		私有的						只能在本类中访问
protected	受保护的						只能在本类、同包、子类中访问
default		默认的(即不加任何修饰符)	只能在本类、同包中访问

范围从大到小:	public > protected > default > private

Object类的toString()

Object类的equals()

equals()用来判断两个对象的内容是否相等

而==判断两个对象的内存地址是否相等

默认sun公司编写的equals方法如下:

public boolean equals(Object var1) {
        return this == var1;
    }

举例重写equals方法:

package Demo;
/**
 * 重写equals方法,使之能够比较两个对象的内容是否相等,符合我们的需要
 * 默认的equals方法只能比较两个对象的内存地址
 */

class date{
    int year;
    int month;
    int day;
    public date(int year, int month, int day){
        this.year = year;
        this.month = month;
        this.day = day;
    }

    public boolean equals(Object obj) {
        //如果 obj等于null、obj不属于date、obj内存地址等于this类,就不需要比较了
        if ((obj == null) || !(obj instanceof date) || (obj == this)){
            return false;
        }

        //获取第一个日期
        int year1 = this.year;
        int month1 = this.month;
        int day1 = this.day;
        //获取第二个日期
        date d = (date) obj;    //需要向下转型才能获取到属性值,否则编译的时候提示obj中无year、day、month
        int year2 = d.year;
        int month2 = d.month;
        int day2 = d.day;

        return year1 == year2 && month1 == month2 && day1 == day2;

    }
}
public class Object_euqals {
    public static void main(String[] args) {
        date a = new date(2021,6,13);
        date b = new date(2021,6,13);
        System.out.println(a.equals(b));
    }

}

String类的equals、toString方法

String类已经重写equals方法了,可以直接用来比较两个字符是否相等:
在这里插入图片描述

public class Object_euqals {
    public static void main(String[] args) {
        String c = new String("DMIND");
        String d = new String("DMIND");
        System.out.println(c == d);         //false
        System.out.println(c.equals(d));    //true
    }
}

toString() 返回该对象的字符串表示

String类也重写了toString方法。使用String类比较相等要用equals而不是==

public class Object_euqals {
    public static void main(String[] args) {
        String c = new String("DMIND");
        System.out.println(c);        			  //DMIND
        System.out.println(c.toString());         //DMIND
    }
}

何时用 == 或 equals比较相等?

java中基本数据类型比较是否相等,使用==
java中所有的引用数据类型比较是否相等,使用equals方法

equals()方法的又一个例子

package Demo;

public class Test_equals {
    public static void main(String[] args) {
        User a =new User("DMIND",new Address("广东","第一街道","66666"));
        User b =new User("DMIND",new Address("广东","第一街道","66666"));
        System.out.println(a.equals(b));
    }
}

class User{
    String name;	//String类
    Address addr;	//Address类
    public User(){}
    public User(String name, Address addr){
        this.name = name;
        this.addr = addr;
    }

    public boolean equals(Object obj) {
        if(obj == null || !(obj instanceof User)) return false;
        if(this == obj) return true;

        User u = (User) obj;
        if(this.name.equals(u.name) && this.addr.equals(u.addr)){   //this.addr属于Address类,调用Address类的equals()
            return true;
        }
        return false;
    }
}

class Address{
    String City;
    String street;
    String pcode;
    public Address(){}
    public Address(String City,String street,String pcode){
        this.City = City;
        this.pcode = pcode;
        this.street = street;
    }

    public boolean equals(Object obj) {
        if(obj == null || !(obj instanceof Address)) return false;
        if(this == obj) return true;

        Address a =(Address) obj;
        if(this.City.equals(a.City)         //用String类的equals比较
                && this.street.equals(a.street)
                && this.pcode.equals(a.pcode)
        ){
            return true;
        }
        return false;
    }
}

Object类的finalize() 垃圾回收

垃圾回收机器(Garbage Collection),也叫GC

  • 当对象不再被程序所使用的时候,垃圾回收器将会将其回收
  • 垃圾回收是在后台运行的,我们无法命令垃圾回收器马上回收资源,但是我们可以告诉他可以尽快回收资源(System.gc()和Runtime.getRuntime().gc())
  • 垃圾回收器在回收某个对象的时候,首先会调用该对象的finalize() 方法
  • GC主要针对堆内存
package Demo;
import java.util.Date;
public class Test_finalize {
    public static void main(String[] args) {
            garbge g = new garbge();	//新建一個類,賦值為null,從而觸發垃圾回收
            g = null;
            System.gc();		//主動調用finalize(),但也只是有機率
       }
}
class garbge{
    @Override
    protected void finalize() throws Throwable {		//重寫 finalize方法
        System.out.println(new Date()+" 銷毀 "+this);
    }
}
//Mon Jun 14 10:11:33 CST 2021銷毀Demo.garbge@24bd3872

内部类

内部类:在类的内部又定义一个新的类,被称为内部类

内部类分类:
静态内部类:类似于静态变量(类变量)
实例内部类:类似于实例变量
局部内部类:类似于局部变量

//定义一个类,其中又有三个内部类
class Test{
    //1.这是静态内部类
    static class StaticInner{

    }
    //2.这是实例内部类
    class InstanceIner{

    }
    //3.这是局部内部类,在一个局部方法中
    public static void main(String[] args) {
        class LocalInner{

        }
    }

}

匿名内部类

匿名内部类是局部内部类的一种。匿名内部类没有名字

举例:使用匿名内部类实现接口

package Demo;

public class Test_AnonymousClasses {
    public static void main(String[] args) {
        My_math m = new My_math();
        m.add(new Computer() {      //匿名内部类
            @Override
            public int addimp(int a, int b) {
                return a+b; 
            }
        }, 100, 200);
        
    }
}

interface Computer{
    int addimp(int a, int b);
}
class My_math{
    public void add(Computer C, int i, int j){
        int res = C.addimp(i,j);    //实际调用接口的addimp方法
        System.out.println(res);
    }
}

数组

  1. Java中的数组是一种引用数据类型。不属于基本数据类型,数组的父类是Object
  2. 数组中可以存储“基本数据类型”的数据,也可以存储“引用数据类型”的数据
  3. 如果数组中存储“Java对象”,存储的是对象的“引用(内存地址)
  4. 数组一旦创建,长度不可变
  5. 所有的数组对象都有length属性,用来获取数组中元素个数
  6. Java中要求数组中元素的类型统一
  7. 数组中元素的内存地址都是连续的
  8. 所有数组都是拿首元素的内存地址作为整个数组对象的内存地址
    在这里插入图片描述

声明 / 定义一个数组:

int[] array1;
double[] array2;
String[] array3;
boolean[] array4;
Object[] array5;

初始化数组:

  • 静态初始化
int[] a1 = {100,200,300};
  • 动态初始化
int[] a2 = new int[5];		//初始化一个长度为5的int类型数组,每个元素默认为0
String[] a3 = new String[5]//初始化一个长度为5的String类型数组,每个元素默认为null

当确定数组中存储哪些具体数据时,采用静态初始化方式
当不确定数组中存储哪些具体数据时,采用动态初始化方式,预先分配内存空间

数组作为方法的参数时

静态初始化和动态初始化各两种:

package Demo;

public class Array {


    public static void main(String[] args) {
        //静态初始化写法一:
        int[] a1 = {100,200,300};
        printArray(a1);
        //动态初始化写法一:
        int[] a2 = new int[3];
        printArray(a2);
        //动态初始化写法二:省却中间变量
        printArray(new int[4]);
        //静态初始化写法二:
        printArray(new int[]{100,200,300});	//语法就是这样的..
    }

    public  static void printArray(int[] args) {
        for(int i=0; i < args.length; i++ ){
            System.out.println(args[i]);
        }
    }
}

main方法的参数:String[] args

main方法的String[] args参数是留给用户的,用户可以在控制台上输入参数,所输入的参数自动转化为String数组传入main方法

public class Array {

    public static void main(String[] args) {
        printStringArray(args);
    }

    public static void printStringArray(String args[]){
        for (int i = 0; i < args.length; i++) {
            System.out.println(args[i]);
        }
    }
}

CMD上传参数:
在这里插入图片描述
简单地模拟一下登录

public class login {
    public static void main(String[] args) {
        String username = args[0];
        String passwd = args[1];
        if ("admin".equals(username) && "123456".equals(passwd)){
            System.out.println("欢迎admin");
        }
        else{
            System.out.println("用户名或密码错误");
        }
    }
}

数组拷贝

数组需要扩容时使用System.arraycopy()进行数组拷贝

 System.arraycopy(src源数组,src起始位,des目标数组,des起始位,拷贝的长度);
package Demo;

public class Test_Arraycopy {
    static String[] str = {"666","DMIND","555"};
    static String[] str2 = new String[5];

    public static void main(String[] args) {
    	//对引用类型的元素进行拷贝
        System.arraycopy(str,0,str2,0,str.length);
        for (int i = 0; i < str2.length; i++) {
            System.out.println(str2[i]);
        }
        
		//对引用类型的元素进行拷贝,拷贝的是其内存地址
        Object[] o1 = {new Object(),new Object(),new Object()};
        Object[] o2 = new Object[5];
        System.arraycopy(o1,0,o2,0,o1.length);
        for (int i = 0; i < o2.length; i++) {
            System.out.println(o2[i]);	
        }
    }
}
这篇关于Java学习【Day 6】的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!