12.14 Java基础12

  • 昨日所学要点回顾
  • 1.多态: 不同对象，对于同一个消息，作出不同的响应;
     *         子类的对象，执行的方法名相同，但是过程和结果不同。执行是在程序的运行期决定。
     *    多态的两种实现方法：     
     *    继承方式:
     *         定义父类，父类有一个方法；创建子类，子类中重写父类的方法;场景类中方法，参数为父类引用;
     *         而调用的时候，传递的是子类对象。具体执行的方法由子类对象来决定。
     *         
     *    接口:
     *         定义接口，接口有一个抽象方法；创建接口的实现类，重写父接口的方法;场景类中方法，参数为接口引用;（注意：到这一步，选择传递的参数就可能是接口或者实现类对象，换言之就是不确定）
     *         调用的时候，传递的是实现类对象。具体执行的方法由实现类对象来决定。
     *         
     *         
    2.抽象类和接口区别：
     * 
     * 抽象类:
     *   本质上就是类，也有构造方法，普通方法，静态方法，抽象方法;不能直接实例化，只支持单继承。
     * 接口:
     *   特殊的抽象类，没有构造方法，可以有默认方法和静态方法，可以有抽象方法，公共静态常量。

 

  • final和static关键字
  • final
  • final的意思是最终的，不可修改的，可用于声明属性，方法和类。
  • final修饰属性

如果某个变量被final修饰，那么该变量就成为常量，不能被修改，常量名通常大写。

常量在声明时必须初始化（在构造方法里赋值或是在声明时直接等号赋值，往往与static一起使用），声明之后不能对其进行二次赋值，其后任何试图对常量进行赋值的语句都将报错。

保证创建每一个对象的时候，final属性的值是确定的。

 [访问权限] final 数据类型 常量名 = 值;

另外，在方法参数前加final关键字，是为了防止数据在方法体中被修改。

  • final修饰方法

如果将某个成员方法修饰为final，则意味着该方法不能被子类覆盖，这就和抽象方法必须由子类实现的规定互相矛盾，因此，final和abstract不能同时修饰一个方法。

[访问权限] final 返回值类型 方法名(参数列表) {

  ……

  }

  • final修饰类

如果将某个类修饰为final，则说明该类无法被继承。

[访问权限] final class 类名 {

  成员列表

Java中有一个最常用的final类：java.lang.String

  • static
  • 定义

static被称为静态，可以用来修饰类的属性或者方法。

如果类的某个属性，不管创建多少个对象，属性的存储空间只有唯一的一个，那么这个属性就应该用static修饰，被static修饰的属性被称为静态属性，被static修饰的方法被称为静态方法。

static属性可以使用对象调用，也可以直接用类名调用。

静态属性是类的，不过所有对象共享，即不管创建了多少个对象，静态属性在内存中只有一个。

注意：被调用进行运算后的静态变量值可以重复使用。

  • 静态成员变量

被static修饰的成员变量被称为静态成员变量或者是静态属性。静态的属性与对象没有关系，是所有对象共享的，只与类有关。

  • 静态方法

如果某个方法不需要与某个特定的对象绑定，那么该方法可以使用static修饰，被static修饰的方法称为静态方法。

关于静态方法的调用：可以使用对象调用，也可以直接用类名调用，不过建议用类名直接调用。

  • 静态方法总结

本类的方法之间的调用

静态方法可以被任何方法(静态方法和非静态方法)直接调用；

非静态方法可以被非静态方法直接调用；

非静态方法不能被静态方法直接调用，需要创建对象，用对象名调用(原因：类加载之后可以调用静态方法，而那时对象可能还没实例化，自然也就没有非静态方法可调用)。

不同类方法之间的调用

调用静态方法，使用类名直接调用;

非静态方法不能直接调用，需要创建对象先实例化，用对象名调用。

  • 静态代码块

public class D {
    static {
        System.out.println("1static代码段->用于给类进行初始化，只执行一次，类加载时");// 静态代码段
    }
    {
        System.out.println("2普通代码段->实例一次就一次");// 普通代码段
    }

    public D() {

        System.out.println("3构造方法->给对象初始化，实例一次就一次");// 构造代码块
    }

    public static void main(String[] args) {

        new D();
    }
}

static代码块和构造代码块同时出现时优先级： 静态代码块>构造代码块>构造方法

  • static import机制

JDK1.5中引入了“Static Import”机制，借助这一机制，可以省略掉所在的类或接口名的方式，来使用静态成员。

/**
 * 静态导入 * 全部方法
 */
import static java.lang.Math.*;

public class E {

    public static void main(String[] args) {

        // Math 数学工具类的方法都是静态方法 static import后可以省略类名直接使用导入的成员       

        // public final class Math
        // 类名.方法
        System.out.println(abs(-1));
        System.out.println(random());
        System.out.println((int) sqrt(100.0));
    }
}

  • Object

Object是类层次结构的根类,每个类都使用 Object 作为父类（超类），所有对象（包括数组）都实现这个类的方法。

Object类在java.lang包下，它具备所有对象都具备的共同内容。

Object类中定义了11个方法，任何类都默认拥有（包括数组），可以使用API文档查询；本节课共学了4个很常用的方法。

//返回该对象的字符串表示形式

public String toString()

该方法返回一个字符串，它的值等于:getClass().getName() + '@' +  Integer.toHexString(hashCode())。

//判断二个对象是否相等

public boolean equals(Object obj)

继承自object的equals方法，两个对象比较时比较的是地址值。

//返回该对象的哈希码值

public int hashCode()

当两个引用的虚地址相同时，hashCode返回相同的值，否则返回不同的值。

输出对象的hashcode得到的是一串数字（某个对象的身份证号码）。

//返回Object的运行时类

public final class<T> getClass()

这个暂时还没学，涉及到泛型

注意：比较两个对象时，基于哈希的集合在使用hashCode的时候，基本都是和equals一起使用；hashCode和equals方法重写的时候也一定要一起重写！简单来说，就是通过重写object的hashCode和equals方法从而使比较的两个对象变成相同的。

样例：

public class Pig {

    private String name;
    private String color;

    public Pig(String name, String color) {
        super();
        this.name = name;
        this.color = color;
    }

    public Pig() {
        // TODO Auto-generated constructor stub
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((color == null) ? 0 : color.hashCode());
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        // 判断当前对象和参数obj是否是同一个指向
        if (this == obj)
            return true;
        // 判断obj是否为null
        if (obj == null)
            return false;
        // 判断当前类的类型是obj的类类型是否相同,如果不同直接返回false
        if (getClass() != obj.getClass())
            return false;
        // 将参数obj强制转化为Pig类型
        Pig other = (Pig) obj;
        // 判断属性color
        if (color == null) {
            if (other.color != null)
                return false;
            // 比较的是字符串的的值是否相等
        } else if (!color.equals(other.color))
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        // 两个属性也相等
        return true;
    }
}

 

/**
 * 重要:比较两个对象是否相同，我们通常采用的方法是: 重写hashCode和equals方法;
 * equals方法中，将所有对象的属性值都进行依次比较. 如果所有属性值都相等，最终返回值true
 * 
 * @author Administrator
 *
 */
public class TestPig {
    public static void main(String[] args) {
        Pig p1 = new Pig("可乐", "黑色");
        System.out.println(p1);

        Pig p2 = new Pig("可乐", "黑色");
        System.out.println(p2);

        System.out.println(p1.hashCode());
        System.out.println(p2.hashCode());

        System.out.println(p1.equals(p2));
        System.out.println(p1 == p2);
    }
}

 

  • 数学API
  • Math提供的各类数学方法

Math类位于java.lang包中，是一个final类，不能被继承；

Math类中所有方法都是static方法，可以直接使用类名Math调用；

Math中定义了大量与数学运算有关的方法，包括求绝对值、三角函数、平方根等；

常见方法：

方法声明

方法描述

static double ceil(double a)

返回最小的double 值，该值大于等于参数，并等于某个整数。

static double floor(double a)

返回最大的double 值，该值小于等于参数，并等于某个整数。

static long  round(double a)

返回最接近参数的 long。

static int  round(float a)

返回最接近参数的 int。

static double  random()

返回带正号的 double 值，该值大于等于 0.0 且小于 1.0。

static double sqrt(double a) 

返回的正确舍入正平方根 double值。
  • BigDecimal和BigInteger进行超出Java基本数据类型范围的数字之间的运算

Java中整数最大范围是long型，64位，如果需要使用超过long范围的大整数，可以使用BigInteger类；

BigInteger位于java.math包中，定义了一系列的数学运算方法，调用这些方法可以进行计算，不能使用运算符计算；

java.math包中还有一个类叫BigDecimal，虽然和整数无关，我们也在此一起学习；

BigDecimal是用来针对浮点型进行精确运算的（一般用于商业运算）。

样例代码：

public static void main(String[] args) {
        
        String s1="29219291291919391912919283232323";
        String s2="2007594379874134134134127943";
        
        BigInteger b1 = new BigInteger(s1);
        BigInteger b2 = new BigInteger(s2);
        
        //加法
        System.out.println(b1.add(b2));
    }

 

public static void main(String[] args) {

        BigDecimal b1 = new BigDecimal(1.2345);
        BigDecimal b2 = new BigDecimal(2.2345);

        BigDecimal result = b1.add(b2);

        // 计算
        System.out.println(result);
        result = result.setScale(2, RoundingMode.CEILING);// 保留2位小数
        System.out.println(result);
    }

  • 随机API

java.util包中的Random类可以用来生成不同类型的随机值，功能更为强大。

方法声明

方法描述

Random()

创建Random对象，该对象每次生成的随机数不同

Random(long seed)

使用一个种子参数创建Random对象，参数相同的Random对象，每次生成的随机数相同。

java.util包中的Random类有多个生成随机数的相关方法

方法声明

方法描述

int nextInt()

生成int类型随机数，数值范围不定；

int nextInt(int n)

生成int类型随机数，数值范围[0,n)；

long nextLong()

生成long类型随机数

float nextFloat()

生成float类型随机数，数值范围[0,1.0)；

double nextDouble()

生成double类型随机数，数值范围[0,1.0)；

boolean nextBoolean()

生成boolean类型随机数；

void setSeed(long seed)

修改Random对象的种子值
      可惜Random生成的随机数还是伪随机数，因为生成次数一多，数字的重复肉眼可见。

public static void main(String[] args) {

        Random r = new Random();
        for (int i = 1; i <= 10000; i++) {
            int result = r.nextInt(100);
            System.out.println(result);
        }
    }

  • UUID

UUID是通用唯一识别码 (Universally Unique Identifier)的缩写，是唯一的机器生成的标识符。

java.util.UUID 类定义了生成UUID的方法：

public static void main(String[] args) {

        for(int i=0;i<10;i++){

  UUID uuid=UUID.randomUUID();

  System.out.println(uuid);

        }

}

 

感想：今天教的还是很多，还好都能接受，代码可以敲出来，回家再看下，明天要学时间日期，字符串和包装类，晚上回家好好预习。

18:42:32 2021-12-14

posted on 2021-12-14 18:42  heyiyang1312  阅读(9)  评论(0)    收藏  举报

导航