java 基础增强

最新推荐文章于 2023-07-03 14:40:28 发布
最新推荐文章于 2023-07-03 14:40:28 发布
阅读量260 收藏 1
点赞数
分类专栏： java 文章标签： 枚举 junit 静态导入
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_15797229/article/details/74178906
版权

java基础

//文件复制
public class Demo1 {
    public static void main(String[] args) throws Exception {
        InputStream is = new FileInputStream("F:\\MyEclipseWorkSpace\\myday01\\src\\cn\\itcast\\java\\tools\\myday01\\myday01.txt");
        OutputStream os = new FileOutputStream("F:\\MyEclipseWorkSpace\\myday01\\src\\cn\\itcast\\java\\tools\\myday01\\复件myday01.txt");
        byte[] buf = new byte[1024];
        int len = 0;
        while(is.read(buf) > 0) {
            os.write(buf, 0, len);
        }
        is.close();
        os.close();
    }
}

//使用断点[step over:快捷键F6]
public class Demo2 {
    public static void main(String[] args) {
        int sum = 0;
        for (int i = 0; i <= 10; i++) {
            sum += i;
        }
        System.out.println(sum);
    }
}

//调试方法间的调用关系
//使用断点[step in:快捷键F5]
public class Demo3 {
    public static void main(String[] args) {
        a();
        System.out.println("main()");
    }
    public static void a() {
        b();
        System.out.println("a()");
    }
    public static void b() {
        c();
        System.out.println("b()");
    }
    public static void c() {
        System.out.println("c()");
    }
}

junit的使用

//使用junit运行程序
public class Demo1 {
    @Test
    public void test1() {
        System.out.println("Junit使用");
    }
    @Test
    public void test2() {
        System.out.println("Junit调试");
    }
}

//在myeclipse中的Window --> Show View --> Outline中选择要运行的方法，上述例子中选test1()方法就执行test1()方法；选test2()方法就执行test2()方法；选Demo1就两个方法都执行

//在每个方法执行前后执行一次setUp（）方法和tearDown（）方法
public class Demo2 {
    @Before
    public void setUp() throws Exception {
        System.out.println("setup()");
    }
    @Test
    public void test1() {
        System.out.println("Test1()");
    }
    @Test
    public void test2() {
        System.out.println("Test2()");
    }
    @After
    public void tearDown() throws Exception {
        System.out.println("teardown()");
    }
}


//在每个类前后执行一次setUpBeforeClass()方法和tearDownAfterClass()方法
public class Demo3 {
    @BeforeClass
    public static void setUpBeforeClass() throws Exception {
        System.out.println("setUpBeforeClass()");
    }
    @Test
    public void test1() {
        System.out.println("test1()");
    }
    @Test
    public void test2() {
        System.out.println("test2()");
    }
    @AfterClass
    public static void tearDownAfterClass() throws Exception {
        System.out.println("tearDownAfterClass()");
    }
}

静态导入

import org.junit.Test;
import static java.lang.Math.PI;
import static java.lang.Math.pow;
import static java.lang.System.out;
//静态导入(导入静态的对象，属性，方法)
//crtl+shift+x转换成大写  crtl+shift+y转换成小写
public class Demo1 {
    @Test
    public void test() {
        double r = 2.3;
        out.println("圆的面积:" + PI * pow(r, 2));
    }
}

自动拆装箱

/*自动拆装箱 JDK5(自动将基本类型和包装类型进行转换)
 * int<->Integer
 */
//crtl+shift+o一次性导入多个包
public class Demo1 {
    @Test
    public void test1() {
        List<String> list = new ArrayList<String>();//尖括号对集合中的类型进行限制
        list.add("jack");
        String name = list.get(0);
        System.out.println("name=" + name); //name=jack
    }
    @Test
    public void test2() {
        int i = 100;
        List list = new ArrayList();
        list.add(i);
        Integer num = (Integer)list.get(0);
        System.out.println("num = " + num); //num = 100
    }
}

增强for循环与集合（Set,List,Map）迭代

//增强for循环(多用于遍历内容)
public class Demo1 {
    @Test
    public void test1() {
        int[] is = {1, 2, 3, 4, 5};
        for(int i = 0; i < is.length; i++) {
            System.out.print(is[i] + " ");
        }
    }
    @Test
    public void test2() {
        int[] is = {1, 2, 3, 4, 5};
        for(int value : is) {
            System.out.print(value + " ");
        }
    }
    @Test
    public void testSet() {
        //set中不允许出现重复元素
        Set<Integer> set = new HashSet<Integer>();
        set.add(100);
        set.add(200);
        set.add(300);
        //传统方式遍历集合
        Iterator<Integer> it = set.iterator();
        while(it.hasNext()) {
            Integer key = it.next();
            System.out.println(key + " ");
        }
    }
    @Test
    public void testList() {
        List<String> list = new ArrayList<String>();
        list.add("jack");
        list.add("marry");
        list.add("sisi");
        //增强for循环遍历集合
        for(String name : list) {
            System.out.print(name + " ");
        }
    }
    @Test
    public void testMap1() {
        Map<Integer,String> map = new HashMap<Integer, String>();
        map.put(100, "jack");    //key = 100  value = "jack"
        map.put(200, "marry");
        map.put(300, "sisi");
        Set<Integer> set = map.keySet();//只获取key值，将map转换为set
        Iterator<Integer> it = set.iterator();
        while(it.hasNext()) {
            Integer key = it.next();
            String value = map.get(key);
            System.out.println(key + "-" + value);
        }
    }
    @Test
    public void testMap2() {
        Map<Integer,String> map = new HashMap<Integer, String>();
        map.put(100, "jack");   
        map.put(200, "marry");
        map.put(300, "sisi");
        Set<Entry<Integer, String>> set = map.entrySet();//entry中存储的是记录<key,value>
        Iterator<Entry<Integer, String>> it= set.iterator();
        while(it.hasNext()) {
            Entry<Integer, String> entry = it.next();
            Integer key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key + "<->" + value);
        }
    }
}

迭代Map的两种方式：

//迭代集合注意的细节
//ctrl+/ 单行注释和取消
//ctrl+shift+/ 注释  ctrl+shift+\ 取消注释
public class Demo2 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("jack");
        list.add("marry");
        list.add("sisi");
        //传统方式遍历集合
//      Iterator<String> it = list.iterator();
        ListIterator<String> it = list.listIterator();
        while(it.hasNext()) {
            String key = it.next();
            System.out.print(key + " ");
            //list.add("qq");
            //动态通知迭代器，加入了新元素，从而迭代器自动通知list集合
            it.add("qq");
        }
        System.out.println("list后长度:" + list.size());
        it = list.listIterator();
        while(it.hasNext()) {
            String key = it.next();
            System.out.print(key + " ");
        }
    }
}

//在迭代集合时，一定要动态通知Iterator，而不要动态通知List集合，应选用ListIterator

可变参数

//可变参数
public class Demo1 {
    public static void main(String[] args) {
        String[] arr = {"jack", "marry", "sisi", "soso"};
//      show1(arr);
//      show2(arr);
        show3("qq","jack", "marry", "sisi", "soso");
    }
    public static void show1(String[] arr) {
        for(String a : arr) {
            System.out.print(a + " ");
        }
    }
    public static void show2(String...arr) {
        for(String a : arr) {
            System.out.print(a + " ");
        }
    }
    //可变参数只能放置在参数列表最后
    public static void show3(String qq, String...arr) {
        System.out.println("第一个参数是:" + qq); //第一个参数是qq
        for(String a : arr) {
            System.out.print(a + " ");
        }
    }
}

//可变参数
//1、参数的个数是不确定的
//2、可变参数只能放置在参数的最后，即最右边
//3、可变参数最少0个，最多1个
//4、编译器将可变参数当作一个一维数组来对待

//枚举
//1、当取值是某范围中的之一，这时可以使用枚举
//2、每一个枚举值相当于该枚举类的一个实例变量 
//3、枚举类与普通类一致，可以继承或实现，如果有抽像方法的话，可以利用每个枚举值以匿名内部类的方式去实现，枚举类的构造方法必须是私有的
//4、枚举值可以用在switch()语句中

//运行时验证枚举：
//学生
public class Student {
    //姓名
    private String name;
    //等级
    private String grade; //等级只能是A，B，C，D，E
    public Student(){}
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getGrade() {
        return grade;
    }
    public void setGrade(String grade) throws Exception {
        //matches()方法中的参数为正则表达式,枚举类型有matches()方法
        if(grade!=null && grade.matches("A|B|C|D|E")) {
            this.grade = grade;
        }else{
            throw new Exception();
        }
    }
}

//选中行+Alt+上下键任意移动代码
public class Demo1 {
    public static void main(String[] args) throws Exception {
        Student student = new Student();
        student.setName("jack");
        student.setGrade("D");
        //student.setGrade("F");  抛出错误
        System.out.println("姓名:" + student.getName());
        System.out.println("等级:" + student.getGrade());
    }
}

//编译时验证枚举：
//分数类
public class Grade {
//模拟枚举
    public static Grade A = new Grade("A", "90-100");
    public static Grade B = new Grade("B", "80-89");
    public static Grade C = new Grade("C", "70-79");
    public static Grade D = new Grade("D", "60-69");
    public static Grade E = new Grade("E", "<60");
    private String tip;
    private String desc;
    private Grade(String tip, String desc) {
        this.tip = tip;
        this.desc = desc;
    }
    public String getTip() {
        return tip;
    }
    public String getDesc() {
        return desc;
    }
}

//学生
public class Student {
    //姓名
    private String name;
    //分数类
    private Grade grade;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Grade getGrade() {
        return grade;
    }
    public void setGrade(Grade grade) {
        this.grade = grade;
    }   
}

//选中行+Alt+上下键任意移动代码
public class Demo1 {
    public static void main(String[] args) throws Exception {
        Student student = new Student();
        student.setName("jack");
        student.setGrade(Grade.A);
        System.out.println("姓名:" + student.getName());
        System.out.println("等级:" + student.getGrade().getTip());
        System.out.println("分数区间:" + student.getGrade().getDesc()); 
    }
}

//编译时验证枚举：
//分数枚举类
public enum Grade {
    A("A", "90-100"),
    B("B", "80-89"),
    C("C", "70-79"),
    D("D", "60-69"),
    E("E", "<60");
    private String tip;
    private String desc;
    private Grade(String tip, String desc){
        this.tip = tip;
        this.desc = desc;
    }
    public String getTip() {
        return tip;
    }
    public String getDesc() {
        return desc;
    }
}

//学生
public class Student {
    //姓名
    private String name;
    //分数类
    private Grade grade;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Grade getGrade() {
        return grade;
    }
    public void setGrade(Grade grade) {
        this.grade = grade;
    }   
}

//选中行+Alt+上下键任意移动代码
public class Demo1 {
    public static void main(String[] args) throws Exception {
        Student student = new Student();
        student.setName("marry");
        student.setGrade(Grade.A);
        System.out.println("姓名:" + student.getName());
        System.out.println("等级:" + student.getGrade().getTip());
        System.out.println("分数区间:" + student.getGrade().getDesc()); 
    }
}

//枚举类常用方法：
//季节枚举类
public enum Season {
    SPRING{
        public void show() {
            System.out.println("春天");
        }   
    },
    SUMMER{
        public void show() {
            System.out.println("夏天");
        }
    }, 
    AUTOMN{
        public void show() {
            System.out.println("秋天");
        }
    },
    WINNTER{
        public void show() {
            System.out.println("冬天");
        }
    };
    public abstract void show();
}

/**
 * 枚举类的常用方法
 * @author L J
 */
public class Demo1 {
    public static void main(String[] args) {
        Season season = Season.AUTOMN;
        //打印枚举值
        System.out.println(season.name());    //AUTOMN
        //打印枚举值下标
        System.out.println(season.ordinal()); //2
        //遍历枚举类中的枚举值
        Season[] seasons = season.values();  
        for(Season s : seasons) {
            System.out.println(s.name());
        }

        //判断SPRING是否是枚举类中的值,是就返回枚举名称，不是抛出异常
        Season flag = Season.valueOf(Season.class, "SPRING");
        System.out.println(flag); //SPRING
        season.show(); //秋天

        //枚举用于switch语句
        String msg = null;
        switch(season) {
        case SPRING:
            msg = "1";
            break;
        case SUMMER:
            msg = "2";
            break;
        case AUTOMN:
            msg = "3";
            break;
        case WINNTER:
            msg = "4";
            break;
        }
        System.out.println(msg); //3
    }
}
kd_myway
关注
专栏目录
Java基础加强
12-19
"Java基础加强"的课程或学习资源通常旨在帮助初学者巩固和深化对Java基础知识的理解，以便更好地掌握这门语言的核心概念和技术。在这个主题中，我们将探讨几个关键的知识点： 1. **Java语法基础**：包括数据类型...
java基础增强
cilderella的专栏
05-21 460
枚举的定义： 将对象在enum类中一一列举 枚举的作用： 可以自定义对象属性和方法 枚举的常用方法： name() valueOf() 注意点：枚举中声明的变量都是private； 可以定义一个抽象方法，在枚举中对每个对象创建一个匿名内部类来实现这个抽象方法实现对象属性的设置
Java基础增强(新特性)
Aming_he博客
09-02 158
JDK5新特性 JDK5新特性： 自动装箱和拆箱 泛型 增强for循环 静态导入 可变参数 枚举   枚举：   枚举概述 是指将变量的值一一列出来,变量的值只限于列举出来的值的范围内。举例：一周只有7天，一年只有12个月等。 回想单例设计模式：单例类是一个类只有一个实例 那么多例类就是一个类有多个实例，但不是无限个数的实例，而是有限个数的实例。这才能是枚举类。 枚举 通过自己定义一个...
JAVA技术增强
begpro的博客
09-03 617
Java技术增强的粗略知识框架
Java基础：基础加强
Ron
09-26 2739
Java enhance
年java基础加强.pptx
11-21
Java基础加强是编程学习的重要阶段，它涵盖了众多关键概念，帮助开发者掌握Java语言的基础技能。在2020年的Java基础加强课程中，Eclipse的使用是一个重要部分。Eclipse是一个广泛使用的Java集成开发环境（IDE），...
JAVA基础加强
12-04
java基础加强版 ，更人性的巩固基础，万丈高楼平地起，只有打好基础，才能理解更复杂的东西
Java基础加强系列视频课程
07-22
资源名称：Java基础加强系列视频课程资源目录：【】黑马程序员Java基础加强（01-10）【】黑马程序员Java基础加强（11-20）【】黑马程序员Java基础加强（21-30）【】黑马程序员Java基础加强（31-40）【】黑马程序员...
Java基础面试题
最新发布
qq_36212439的博客
07-03 937
Java基础面试题
JavaSE基础加强（面向对象进阶）
wangjh11234的博客
03-17 200
JavaSE基础加强（面向对象进阶）
Java高频面试基础知识点整理
热门推荐
张彦峰的博客
11-04 167万+
Java高频面试知识点总结：覆盖高频基础知识考点+高频集合知识点深入分析+高频多线程与并发编程面试题汇总+其他扩展考察等。
JAVA_SE笔记【完结】
zidieq的博客
09-29 435
JAVASE学习笔记Hello World环境变量概念Java语言平台版本类文件结构 Hello World 环境变量 JAVA_HOME C:\Program Files\Java\jdk1.8.0_291 Path ;C:\Program Files\Java\jdk1.8.0_291\bin; CLASS_PATH C:\Program Files\Java\jdk1.8.0_291\lib; 概念 JDK(Java Development Kit) — Java开发工具包 — JRE+开发工具
java 基础加强_java基础加强
weixin_39803552的博客
02-15 106
分离接口和实现接口和实现分离的好处是，你在编程的时候可以用接口类型来代表一个具体集合的引用，当你改变主意时，你只需要使用不同的集合实现类即可，如下例1List expressLane = new ArrayList<>;1List expressLane = new LinkedList<>;Collection接口Collection接口是最基本的集合接口，它提供了两个最...
JAVA-基础加强
xiaosongshi的博客
03-14 170
第一节 基础加强 第二节 反射 第三节 注解
Java基础增强（新特性）
LyncDwight的博客
05-30 209
Java基础增强（新特性）本章内容l JDK5新特性l JDK6新特性(很少见所以不讲)l JDK7新特性l JDK8新特性(我给出资料，自己看一下) JDK5新特性l 自动装箱和拆箱l 泛型l 增强for循环l 静态导入l 可变参数l 枚举  枚举l 枚举概述•    是指将变量的值一一列出来,变量的值只限于列举出来的值的范围内。举例：一周只有7天，一年只有12个月等。•     回想单例设计模...
Java基础增强
jackly654的专栏
03-26 492
工程管理与快捷键配置 keys workspace与project preferences JAVA compiler编译器 Installed JREs运行 ------------------- myeclipse下怎样调试 双击设置断点 然后进入
java 之Java基础增强(新特性)
流年りゅう
11-19 571
JDK5新特性自动装箱和拆箱 泛型 增强for循环 静态导入 可变参数 枚举 枚举枚举概述 是指将变量的值一一列出来,变量的值只限于列举出来的值的范围内。举例：一周只有7天，一年只有12个月等。 回想单例设计模式：单例类是一个类只有一个实例 那么多例类就是一个类有多个实例，但不是无限个数的实例，而是有限个数的实例。这才能是枚举类。通过自己定义一个枚举类来演示案例 第一版 第二
java基础增强之其他小知识
zhoulenihao的专栏
09-10 1488
---------------------- ASP.Net+Android+IO开发S、.Net培训、期待与您交流！ ---------------------- 1.静态导入 概念：当我们想调用一个静态方法，但是又不想写类的名称的时候，可以使用静态导入 比如要导入Math类中的一些静态方法，原来是这么写： Math.abs(num)//调用Math类中的abs方法计算一个数的绝对值
Java基础加强与高新技术实战
"张孝祥_Java_基础加强_高新技术.ppt" 是一份关于Java编程的高级培训资料，由北京传智播客教育提供，旨在提升学员的Java基础和实战技能。 这份资料首先强调了学习过程中记录和整理笔记的重要性，以及安装开发环境如...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值