你的 “内部类的“类” 请收好！

最新推荐文章于 2021-08-03 13:41:18 发布

Rike_M

最新推荐文章于 2021-08-03 13:41:18 发布

阅读量249

点赞数

分类专栏： java 文章标签： java 编程语言

本文链接：https://blog.csdn.net/Rike_M/article/details/109271149

版权

java 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

一，类

1.1 类的概念

它是一种抽象的概念。对于初学者来学不容易理解。它代表的是某一特殊的群体、或者是具备一定行为（功能）和属性事物。
怎么理解类？简单来说，人类就是一个类，动物也是一个类，也就是一个把一些事物整合起来称呼的一个集合，跑步，跳绳，游泳都属于运动，运动就是一个类。而在Java中，则是对某一组引用数据类型的统称。

1.2 类的定义

修饰符 class 类名 {
类中的内容
}
目前学习的修饰符有public private。。。等

二，内部类

2.1定义

在一个类中，定义另一个类的代码结构，通常定义在类内部的类称为 “ 内部类” ，外面的类称为 “ 外部类” ，在逻辑关系上内部类与外部类是从属关系，比如一个People类存在收获地址类（收货人，收货联系方式）

2.2分类

2.2.1普通内部类（inner class）：一个类A中定义另一个类B，其中类B就是类A的内部类，也是类A的一部分

public class People {
private String pname=“张三”;

public void sayHello(){
    System.out.println("Let us say Hello");
    // 知识点1 ：外部类的方法中，可以使用内部类的属性、方法
    Address address = new Address();
    address.addressName ="湖北武汉";
    address.contentName="张某某";
    address.showAddressInfo();
}


/**
 * 定义普通内部类   收货地址
 */
class Address{
    private String addressName;// 收货地址
    private String contentName;// 联系人

    public void showAddressInfo(){
        System.out.println("联系人："+contentName + "--收货地址："+addressName);
        // 内部类的方法 可以直接访问外部类的属性  （由于通常情况属性的访问必须通过对象才可以使用，而）
        System.out.println("访问外部类的属性："+pname);
    }
}

注意两点、

外部类的方法中，可以直接访问内部类的所有成员（包括私有）
内部类的方法中，也可以直接方法外部类的所有成员，当外部和内部的成员名相同时，就近原则访问成员，或者引入外部类的对象访问

2.2.2 静态内部类（static inner class）：在普通内部类的基础上，增加 " static" 关键字，与静态方法相似，满足静态的要求

public class People{
/**
     * 2、定义静态内部类
     *   卡信息
     */
    static  class Card{
        private static String cardNo="4200018888000022";
        private String cardName="身份证";

        // 定义静态方法
        public static void showCard(){
            System.out.println("身份证号："+ cardNo);
        }
        // 定义非静态方法
        public void showCard2(){
            System.out.println("cardName:"+cardName + "----"+ cardNo);
        }
   
    }

	// 外部类的方法 
    public void method2(){
        Card card = new Card();
        // 对于静态方法可以直接类名.方法名
        // 对于非静态方法，需要创建Card类的对象访问
        card.showCard2();


    }
}

使用：
        // 2 创建静态内部类的对象
        People.Card.showCard();
        // 创建静态内部类的对象
        People.Card  card = new People.Card();
        card.showCard2();

2.2.3方法内部类：在一个方法中定义的类，其中这个类只属于该方法，也只能在该方法中使用

 /**
     * 3、方法内部类 （将一个类定义在方法里面）
     */
    public void method3(){
         int score = 98;

         // 在这里定义一个类
        class MyClass{
            String subject="Java";
            public void getSubjectScore(){
                //方法内部类中 也可以使用方法的属性
                System.out.println(pname+"的"+subject+":"+score);
            }
        }

        //调用方法里面的类
        MyClass  mycls = new MyClass();
        mycls.getSubjectScore();

People people =new People（）；
//3  调用方法
  people ,method3();
   }
内部类剩下的class文件 命名 外部类￥内部类名.class

2.2.4匿名内部类：定义一个没有类名，只有对方法的具体实现。通常它依赖于实现关系（接口）或继承关系（父类）

a，基于实现关系
public interface MyInterface {
    // 学习
    public void  study();
    //  工作
    public void work();
}
// 创建一个匿名类(让接口的引用 指向匿名类的对象)
        MyInterface  person = new MyInterface() {
            @Override
            public void study() {
                System.out.println("这个人也好好学习");
            }

            @Override
            public void work() {
                System.out.println("这个人也好好工作");
            }
        };

        person.study();
        person.work();

b，基于继承关系

public class MyClass {

   public void service(){
        System.out.println("提供服务的方法。");
    }
}


 // 父类 new 一个 匿名类，这个匿名类是它的子类
        MyClass cls = new MyClass(){
            @Override //匿名类重写父类的方法 service
            public void service() {
                System.out.println("这是子类的方法");
            }
        };
        cls.service();

三，StringBuffer 和 StringBuilder类

3.1 StringBuffer

是一个字符串缓冲区的类，线程安全，运行效率低，用于存储可变字符串

构造器

  StringBuffer sb= new stringbuffer（）；//创建空容器
     stringBuffer sb =new  stringBuffer（String）；//将字符串使用容器存储
       stringBuffer sb =new  stringBuffer（int）； 声明指定容量的容器

常用方法：

1.1 append（）：追加字符串

1.2 delete（int start ，int end）：删除指定位置的字符

1.3 insert（int start ，string）：插入到指定位置

1.4 reverse （）：反转字符

1.5 capacity（）：获取初始容量

1.6 ensureCapacity（int）：设置最低所需容量

3.2StringBuild 类

也是字符串缓冲区的类，它是线程不安全，且运行效率高的可变字符串缓冲类。
在这里插入图片描述
tring Buffer StringBuild 和 String区别

区别1：在运行速度上：StringBuild>StringBuffer>String

原因：String是字符串常量，而StringBuild和StringBuffer是字符串变量，当需要改变字符串内容时，String重新创建变量并赋值，而StringBuild和StringBuffer可直接该改变原有的值，所以效率高

线程安全上：StringBuffer>StringBuild>String

原因：StringBuffer是线程安全的，而StringBuild线程不安全，在StringBuffer上的很多方法增加同步关键字（synchronized），导致在多个线程运行时，保持数据的完整性和一致性，而StringBuild的方法并没有同步，如果在多线程情况下为了确保数据安全，建议使用StringBuffer，如果在单线程环境下，提高效率使用StringBuild

其StringBuffer 和 StringBuild 方法基本一样

四，枚举类

4.1枚举类的诞生

在jdk5以前，定义常量需要使用public final static。。单独定义，如果有一组常量，需要定义一组final修饰的类型。这样会很繁琐，jdk5以后推出枚举类型，可以将一组常量定义一个自定义类，使用时通过该类型直接方法

4.2枚举类语法

  public  enum 枚举类型名称{
      值1，值2，值3...
  }
  访问时： 枚举类型名称.值1

ublic enum Color {
    RED(),YELLOW(),BLUE();

}
 public static boolean isRedColor(Color color){
        if(color.equals(Color.RED)){
            return true;
        }
        return false;
    }
    
 public static void main(String[] args) {
        System.out.println(isRedColor(Color.BLUE));
        System.out.println(isRedColor(Color.RED));
}

用法2 ：定义枚举类的属性并赋值

public enum PROVINCES {
    //枚举的值  在初始化枚举值时，通过构造器给它的属性赋值
    HB("湖北",0),BJ("北京",1),HN("湖南",2),FJ("福建",3);

    //枚举的属性
    private String provinceName;
    private int index;
    //枚举的构造器
    private PROVINCES(String provinceName,int index){
        this.provinceName= provinceName;
        this.index = index;
    }

    public String getProvinceName() {
        return provinceName;
    }

    public void setProvinceName(String provinceName) {
        this.provinceName = provinceName;
    }

    public int getIndex() {
        return index;
    }

    public void setIndex(int index) {
        this.index = index;
    }
}

//输出某一枚举的值 name和 index
        System.out.println(PROVINCES.BJ.getProvinceName());
        System.out.println(PROVINCES.BJ.getIndex());

        //遍历所有的枚举的值
         PROVINCES [] provs = PROVINCES.values();
        for(PROVINCES pro :  provs){
            System.out.println(pro.getIndex()+"---"+pro.getProvinceName());
        }

五 Math类

java.lang.Math类用于数学计算的工具类，它提供都是静态方法，不需要构造Math对象

常用对象：

Math.random(): 获取随机数

Math.abs():获取绝对值

Math.ceil(): 向上取整

Math.floor:向下取整

Math.rint：取接近它的整数，如果两个数接近，往接近它的偶数靠近

Math.max(int,int)：返回两个数的最大值

Math.min(int,int)：返回两个数的最小值

Math.round：四舍五入整数

Math.sqrt：对一个数开平方

Math.pow（double，double）：对一个数的几次幂

   public static void main(String[] args) {
        System.out.println(Math.PI);
        System.out.println(Math.E);
        System.out.println(" 一个数的绝对值："+Math.abs(-100));//100
        System.out.println(" 向上取整："+Math.ceil(13.5)); // 14
        System.out.println(" 向上取整(比它大的最近数)："+Math.ceil(-13.5));// -13
        System.out.println("向下取整："+ Math.floor(13.5));// 13
        System.out.println("向下取整"+Math.floor(-20.2));// -21

        //四舍五入
        System.out.println(Math.round(23.4));// 23
        System.out.println(Math.round(-23.5));//-23
        System.out.println(Math.round(-24.5));//-24

        System.out.println(Math.rint(23.4));// 23
        System.out.println(Math.rint(23.5));//24 如果两个一样接近，取接近偶数
        System.out.println(Math.rint(22.5));//22
        System.out.println(Math.rint(0.6));//0

    }

六日历类

6.1 日期类Date

在Java中用于表示日期的类 java.util.Date（），用于获取日期和时间的对象，不过这个类的一些方法以及过时（被日历类取代）

 Date  date = new Date();
 Date date = new Date(long) ;

  // 创建日期类的对象
        Date date = new Date();
        //获取当前时间 以 标准格式
        System.out.println(date);
        // 获取当前时间的毫秒数
        System.out.println(date.getTime());
        //通过毫秒数构建当前时区的 时间
        Date date2 = new Date(100000);
        System.out.println(date2);

        // 获取 纪元时间  相隔本地时间8时区
        System.out.println(date.toGMTString());
        System.out.println(date.toLocaleString());

        //测试时间的先后
        System.out.println(date.after(date2));// true
        System.out.println(date.before(date2));//false
        System.out.println(date.compareTo(date2));//比较时间大小
        // 时间转成字符串
        System.out.println(date.toString());

6.2日历类

java.util.Calendar 是表示日历类，它是一个单例模式，通过 getInstance（）获取一个日历对象，并获取日历的任意时间，日期。

常用方法

getInstance() : 获取日历对象

get() ：获取指定的单位的日历数值（年，月，日等等）

set（）:设置指定单位的日历数值

add() :添加指定单位的日历数值

getTimeInMills() :获取日期的毫秒数

  // 获取当前日历对象
        Calendar cal =  Calendar.getInstance();
        // 日历的属性 （fields）
        System.out.println(Calendar.DATE);
        System.out.println(Calendar.YEAR);
        System.out.println(Calendar.MONTH);
        //获取当前日历的年份
        System.out.println(cal.get(Calendar.YEAR));
        // 获取月份 (返回 0-11)
        System.out.println(cal.get(Calendar.MONTH));
        // 获取日(1-31)
        System.out.println(cal.get(Calendar.DATE));
        // 获取日期
        System.out.println("获取当前日历的日期："+ cal.getTime());
        // 添加日历 （指定的field 和 数量）
        // 将当前日历添加2个月
        cal.add(Calendar.MONTH ,2);
        System.out.println("新的日期："+cal.getTime());
        cal.add(Calendar.DATE,-3);
        System.out.println("新的日期："+cal.getTime());

        // 判断日期的前后 after  before
        // 题目 给定两个日期， 计算相差多少天
        Calendar cal1 = Calendar.getInstance();

计算两个日历（日期）的相差天数/月数

  // 获取当前日历对象
        Calendar cal =  Calendar.getInstance();
        // 日历的属性 （fields）
        System.out.println(Calendar.DATE);
        System.out.println(Calendar.YEAR);
        System.out.println(Calendar.MONTH);
        //获取当前日历的年份
        System.out.println(cal.get(Calendar.YEAR));
        // 获取月份 (返回 0-11)
        System.out.println(cal.get(Calendar.MONTH));
        // 获取日(1-31)
        System.out.println(cal.get(Calendar.DATE));
        // 获取日期
        System.out.println("获取当前日历的日期："+ cal.getTime());
        // 添加日历 （指定的field 和 数量）
        // 将当前日历添加2个月
        cal.add(Calendar.MONTH ,2);
        System.out.println("新的日期："+cal.getTime());
        cal.add(Calendar.DATE,-3);
        System.out.println("新的日期："+cal.getTime());

        // 判断日期的前后 after  before
        // 题目 给定两个日期， 计算相差多少天
        Calendar cal1 = Calendar.getInstance();