JAVA类与对象（3）JAVA类与对象

59 阅读 0 评论 39 点赞

我是靠谱客的博主聪明砖头，最近开发中收集的这篇文章主要介绍JAVA类与对象（3）JAVA类与对象，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

JAVA类与对象

内部类和常用类
内部类、Object类、String类、包装类、BigDecimal类
外部类
创建外部类的匿名对象：new Outer().speak();
1.匿名对象是指没有名字的对象，只能使用一次
内部类
概念：在一个类的内部再定义一个完整的类。
特点：编译之后可形成独立的字节码文件，可以访问外部类的私有成员而不破坏封装。
分为：成员内部类、静态内部类、局部内部类、匿名内部类
成员内部类
在类的内部定义，和实例变量、实例方法同级别的类，作为外部类的实例部分，创建时必须依赖外部对象。如下：Outer.Inner in = new Outer().new Inner();
注：
1.在内部类与外部类有重名属性时，会优先访问内部类属性，要访问外部类的同名属性时，需加上外部类名.this。
2.成员内部类中不能定义静态成员，只有将其设置为静态内部类才能添加静态方法。
3.外部类不能直接使用内部类的资源
4.外部类如果想要使用内部类的资源，需要先创建内部类的对象，通过内部类对象来调用内部类的资源Inner in = new Inner();
5.内部类可以直接使用外部类的资源，私有成员也可以
6.如果成员内部类被private修饰的解决方法

class Outer2{
    public void getInner2(){
        Inner2 inner2 =new Inner2();
        inner2.eat();
    }

    private class Inner2{
        public void eat(){
            System.out.println("我是私有成员内部类的方法eat");
        }
    }
}

静态内部类
当内部类被static修饰时，new Outer()会报错，所以我们无需创建外部类对象，可通过类名找到内部类，直接创建静态内部类的对象即可。调用方式：

 //普通方式
Outer3.Inner3 oi3 = new Outer3.Inner3();
//匿名内部类方式
new Outer3.Inner3().find();
//访问静态内部类的静态方法：链式加载
Outer3.Inner3.delete();

局部内部类
定义在外部类方法中，作用范围和创建方法仅限于当前方法。
注意：直接创建外部类对象调用show()是无法出发内部类的功能的，需要在外部类中创建内部类对象并且调用内部类的功能才能触发

class Outer4{
    public void show(){
        System.out.println("我是外部类的普通方法show");

        class Inner4{
            int sum=22;
            String name;
            public void eat(){
                System.out.println("我是局部内部类的普通方法eat");
            }
        }

        //使用局部内部类的功能
        Inner4 i4 = new Inner4();
        i4.eat();
    }
}

匿名内部类
1.没有类名的局部内部类（所有特征都与局部内部类相同）。
2.必须继承一个父类或实现一个接口。
3.匿名对象只能使用一次，一次只能调用一个方法

package cn.tedu.innerclass;

public class TestInner5 {
    public static void main(String[] args) {
        //相当于3合1：new Inter1()---创建匿名对象
        //{方法的实现}
        //.save()
        new Inter1(){
            @Override
            public void save() {
                System.out.println("正在保存");
            }

            @Override
            public void get() {
                System.out.println("正在获取");
            }
        }.save();


    }
}

interface Inter1{
    void save();
    void get();
}

Object类
1.超类、基类，所有类的直接或间接父类，位于继承树的最顶层。
2.任何类若没有写Extends，都默认为继承Object类，否则为间接继承
3.Object中的方法是所有对象都具备的方法。
4.Object类型可以存储任何对象，作为参数可接受任何对象，作为函数可返回任何对象。
getClass()方法：
public final class<?> getClass(){}，返回引用中存储的实际的对象类型，用于判断两个引用中实际存储对象类型是否一致。
hashCode()方法：
public int hashCode(){}，返回该对象的哈希值，根据地址、字符串、数字计算出来的int类型的值。
toString()方法：
public String toString(){}，返回该对象的字符串表示，如：展示对象各个属性值。
equals()方法：
用于判断两个值是否相同，返回布尔类型，本方法底层的判断逻辑是“==”比较，比较的是左右两边的地址值。
重写之前是通过等等比较的，比较的是值，如果是引用类型（比如自定义的类），比较的是对象名，也就是地址值。
重写之后的效果取决于怎么重写的
finalize()方法：
当对象被判定为垃圾对象时，由JVM自动调用该方法，用于标记垃圾对象，进入回收序列，其中垃圾对象（没有有效引用指向此对象时，为垃圾对象），垃圾回收（由GC销毁垃圾对象），自动回收机制（JVM内存空间耗尽，自动回收垃圾对象释放存储空间），手动回收机制（通过System.gc（）通知JVM回收）。
包装类
1.基本数据类型所对应的引用数据类型。
2.Object可统一所有数据，包装默认值是null。
3.Integer有一个高效的效果，数据在（-128-127）范围内，相同的数据只会存一次，后续使用的都是之前存入的数据（a.范围之内；b.Integer；c.valueOf），并且有且仅有这个有高效效果，Double是没有的
4.Integer包装对象名.parseInt（参数）作用是把String类型的数据转为int；
Double包装对象名.parseDouble（参数）作用是把String类型的数据转为double；
自动装箱与自动拆箱
1.自动装箱会将基本类型int包装成Integer，然后交给Integer类型的引用类型变量保存，自动装箱的底层代码：Integer.valueOf(参数)，方向：int ——> Integer
2.编译器会自动把包装类型的对象拆掉箱子变成基本的数据，然后交给基本类型int的变量i4来保存，自动拆箱底层代码：int型变量名.intValue()，方向：Integer——>int

package cn.tedu.API;

public class TestNumber2 {
    Integer i1 = new Integer(127);
    Integer i2 = Integer.valueOf(127);
    //自动装箱
    Integer i3=5;
    //自动拆箱
    int i4=i1;
}

String类
1.字符串是常量，创建之后不可改变。
2.字符串字面值存储在字符串池中，可以共享。
3.注意常量池的概念，高效创建于普通创建的区别
4.Object类中的equals方法的默认实现是通过等等比较的。但是String类把它重写了，重写之后不再按照等等比较，而是比较两个字符串的具体内容。也就是只要其内容一致，equals就返回true

String name="aaa";  //存储在字符串池中
name="bbb";  //这里的name并没有赋值，而是重新开辟了个空间。
String name2 = new String("aaa");  //产生两个对象，堆和池各一个

char[] name2 = {'C','o','o','l'};
        String str1 = new String(name2);
        String str2 = new String(name2);

        String str3 = "Cool";
        String str4 = "Cool";
        String str5 = "ool";


        System.out.println(str1 == str3);//false，一个在堆里，一个在堆中常量池
        System.out.println(str1 == str2);//false，两个不同的对象，地址值不同
        System.out.println(str3 == str4);//true，都在堆中常量池，并且指向同一个，所以地址值相同
        System.out.println(str3 == str5);//false，都在堆中常量池，但没有指向同一个，指向地址值
		System.out.println(str1.equals(str3));//true
        System.out.println(str1.equals(str2));//true
        System.out.println(str3.equals(str5));//false

String常用方法
串名.length()： 返回字符串长度。
串名.charAt(下标)： 根据下标获取字符。
串名.concat(字符串) ：拼接字符串，只在打印时生效，不影响原字符串
串名.substring(index1，index2)：一个下标时表示从什么位置开始截取字符串；两个下标时表示指定下标范围截取字符串，前闭后开
String.value(参数)：把该参数转为字符串
public boolean contains(String str)：判断当前字符中是否包含str。
public char[] toCharArray()：将字符串转成数组。
串名.indexOf(String str)： 返回str在字符串中首次出现的下标，不存在则返回-1。
串名.lastIndexOf(String str)： 返回str在字符串中最后出现的下标。
串名.trim()： 去掉字符串前后的空格。
串名.toUpperCase()： 将小写转成大写。
串名.toLowerCase()： 将大写转成小写。
串名.startsWith(String str)： 判断字符串是否以str开头。
串名.endsWith(String str)： 判断字符串是否以str结尾。
public String replace(char old,char new)：将就字符串替换为新字符串。
串名.split(String str)： 根据正则表达式str做拆分，返回的是地址值，应使用Arrays.toString()来进行输出。
public int compareTo(String str)：比较大小。
可变字符串
StringBuffer：JDK1.0提供，运行效率慢，线程安全。
StringBuilder：JDK5.0提供，运行效率快，线程不安全。
BigDecimal类
-注意最好不要使用double作为构造函数的参数，不然依然会有不精确的方法，有坑！！
-最好使用String型数据作为构造函数的参数；double转String，直接拼一个空串即可
位于java.math包中，用于精确计算浮点数，创建方式：
BigDecimal bd = new BigDecimal(1.0);
减法：subtract；加法：add；乘法：multiply；除法：divide。

 private static void m2(double a, double b) {
        BigDecimal bd1 = new BigDecimal(a+"");
        BigDecimal bd2 = new BigDecimal(b+"");

        System.out.println("加法运算："+(bd1.add(bd2)));
        System.out.println("减法运算："+(bd1.subtract(bd2)));
        System.out.println("乘法运算："+(bd1.multiply(bd2)));
        System.out.println("除法运算："+(bd1.divide(bd2)));
    }

Date类
表示特定的瞬间，精确到毫秒，Date类中大部分方法都已经被Calender类所替代。1s=1000ms=1000us=1000ns.

package outin;

import java.util.Date;

public class test {
	public static void main(String[] args) {
		//创建日期类
		Date date1 = new Date();
		//输出当前日期时间
		System.out.println(date1.toString());
		// 昨天的时间
		Date date2 = new Date(date1.getTime() - (60 * 60 * 24 * 1000));
		System.out.println(date2.toLocaleString());
		// 判断今天是否在昨天之后
		System.out.println(date1.after(date2));
		//今天比昨天多了多少天
		System.out.println(date1.compareTo(date2));
		//比较是否相等
		System.out.println(date1.equals(date2));
	}
}

Calendar类
提供了获取或设置各类日期字段的方法。
构造方法：protected Calenda() ，由于修饰符是protected，所以无法直接创建该对象。

应用：

package outin;

import java.util.Calendar;

public class test {
	public static void main(String[] args) {
		Calendar cc = Calendar.getInstance();
		//输出日期时间
		System.out.println(cc.getTime().toLocaleString());
		//获取年月日
		int y=cc.get(Calendar.YEAR);
		int m=cc.get(Calendar.MONTH);
		int d=cc.get(Calendar.DAY_OF_MONTH);
		//获取时分秒
		int h=cc.get(Calendar.HOUR_OF_DAY);
		int min=cc.get(Calendar.MINUTE);
		int sec=cc.get(Calendar.SECOND);
		//修改时间(日改为5)
		Calendar cc1 = Calendar.getInstance();
		cc1.set(Calendar.DAY_OF_MONTH, 5);
		//小时减一
		cc1.add(Calendar.HOUR, -1);
		//获取一个月最多有多少天
		System.out.println(cc1.getActualMaximum(Calendar.DAY_OF_MONTH));
	}
}

SimpleDateFormat类
SimpleDateFormat是一个以与语言环境有关的方式来格式化或解析日期的工具类。格式化（日期->文本），解析反之。

package outin;

import java.text.SimpleDateFormat;
import java.util.Date;

public class test {
	public static void main(String[] args) {
		SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy年MM月dd日 HH:MM:ss");
		Date d = new Date();
		System.out.println(sdf1.format(d));
		//解析
		Date d2 = sdf1.parse("2000年10月22日");
	}
}