• 通Java的24堂课,李钟尉 李伟主编。这本书实例丰富,从图书馆借来。先分享光盘内容,大家互相学习。这是课后习题部分。其他部分陆续上传中。
  • Java集合练习题

    2019-05-13 10:59:37
    2. 需要存储10个不能重复的数,需要HashSet集合(当前TreeSet还没学习到) 3. 判断,当HashSet的Size小于10就往里存储随机数,等于就停止添加存储元素 4. 通过Random的nextInt()方法获取随机数并加入到HashSet里 ...

    一.生成10个1到20之间的不重复的随机数

    分析过程:

    1. 需要生成随机数,那么需要Random类

    2. 需要存储10个不能重复的数,需要HashSet集合(当前TreeSet还没学习到)

    3. 判断,当HashSet的Size小于10就往里存储随机数,等于就停止添加存储元素

    4. 通过Random的nextInt()方法获取随机数并加入到HashSet里

    5. 遍历HashSet,打印出10个随机数
     

    package hashset;
     
    import java.util.HashSet;
    import java.util.Random;
     
    public class Test1_HashSet {
     
    	public static void main(String[] args) {
    		
    		//1.创建Random对象
    		Random r = new Random();
    		//2.创建HashSet对象
    		HashSet<Integer> hs = new HashSet<>(); 	//注意是包装类不是int
    		//3.判断并添加元素
    		while(hs.size()< 10) {
    			//4.通过Random中随机方法nextInt()获取1到20范围内随机数
    			hs.add(r.nextInt(20) + 1); 		//如果不加1,随机范围是0到19
    		}
    		
    		//5.遍历HashSet
    		for (Integer integer : hs) {
    			System.out.println(integer);
    		}
    	}
    }

    从键盘获取一行输入字符串,要求去除重复字符。

    分析过程:

    1. 需要使用Scanner类

    2. 输入的是一行字符串,需要转换成字符数组

    3. 创建HashSet集合对象(利用HashSet无法储存相同元素的特性达到去除重复字符的目的)

    4. 字符数组遍历元素,并添加进入HashSet集合

    5. 变量集合元素

    package hashset;
     
    import java.util.Arrays;
    import java.util.HashSet;
    import java.util.Scanner;
     
    import javax.swing.plaf.synth.SynthSpinnerUI;
     
    public class Test2_HashSet {
     
    	public static void main(String[] args) {
    		
    		//1.创建键盘输入对象
    		Scanner sc = new Scanner(System.in);
    		System.out.println("请输入一行字符串:");
    		String line = sc.nextLine();
    		
    		//2.字符串转换成字符数组
    		char[] c = line.toCharArray();
    		
    		//3.字符数组转换成集合对象,创建HashSet
    		HashSet<Character> hs = new HashSet<>();
    	
    		//4.遍历数组,元素依次添加进集合
    		for (int i = 0; i < c.length; i++) {
    			hs.add(c[i]);
    		}
    		
    		//5.遍历HashSet集合
    		for (Character character : hs) {
    			System.out.println(character);
    		}
    		
    	}
     
    }

    假设顺序列表ArrayList中存储的元素是整型数字1~5,遍历每个元素,将每个元素顺序输出。(list集合遍历方法总结)

    import java.util.ArrayList;
    import java.util.Iterator;
    import java.util.List;
    
    //假设顺序列表ArrayList中存储的元素是整型数字1~5,遍历每个元素,将每个元素顺序输出。 [必做题]
    public class MyArray {
        public static void main(String[] args) {
            List<Integer> list = new ArrayList<Integer>();
            list.add(1);
            list.add(2);
            list.add(3);
            list.add(4);
            list.add(5);
            Iterator<Integer> it = list.iterator();
    //      迭代器遍历
            while(it.hasNext()){
                System.out.println(it.next());
            }
    //      for循环遍历
            for(int i = 0;i<list.size();i++){
                System.out.println(list.get(i));
            }
    //      增强for循环
            for(Integer i :list){
                System.out.println(i);
            }
        }
    }
    

     3、在一个列表中存储以下元素:apple,grape,banana,pear 
    • 3.1 返回集合中的最大的和最小的元素 
    • 3.2 将集合进行排序,并将排序后的结果打印在控制台上 

    import java.util.ArrayList;
    import java.util.List;
    
    //3、在一个列表中存储以下元素:
    //apple,grape,banana,pear
    //• 3.1 返回集合中的最大的和最小的元素
    //• 3.2 将集合进行排序,并将排序后的结果打印在控制台上 [必做题
    public class MyScort {
        public static void main(String[] args) {
            List<String> list = new ArrayList<String>();
            list.add("apple");
            list.add("grape");
            list.add("banana");
            list.add("pear");
            for(int j = 0;j<list.size()-1;j++){//冒泡排序
                for(int i = 0;i<list.size()-1-j;i++){
                    if(list.get(i).compareTo(list.get(i+1))>0){
                        String temp = list.get(i);
                        list.set(i, list.get(i+1));
                        list.set(i+1, temp);
                    }
                }
            }
    
            System.out.print("排序后的顺序:");
            for(int i = 0;i<list.size();i++){
                System.out.print(list.get(i)+" ");
            }
            System.out.println();
            System.out.println("集合中最大的元素是"+list.get(0));
            System.out.println("集合中最小的元素是"+list.get(3));
        }
    }
    

     

    编写程序,获取命令行参数中的字符串列表,输出其中重复的字符、不重复的字符以及消除重复以后的字符列表。

    public static void main(String[] args) {
        String str = "abcdeafblmbnopawc";
        System.out.println("原字符串:"+str);
    
    
        Set<Character> set1 = new HashSet<Character>();//消除重复后的字符
        Set<Character> set2 = new HashSet<Character>();//重复的字符
        Set<Character> set3 = new HashSet<Character>();//不重复的字符
    
        //把字符串转为字符数组
        char[] cs = str.toCharArray();
        for (char c : cs) {
            boolean b = set1.add(c);
            if(!b){
                set2.add(c);
            }
        }
    
        //把消除重复后的字符赋给set3
        set3.addAll(set1);
        //把消除重复后的字符 - 重复的字符 = 不重复的字符
        set3.removeAll(set2);
    
        System.out.println("====消除重复后的字符========");
        for (char c : set1) {
            System.out.print(c+" ");
        }
    
        System.out.println("\n====重复的字符========");
        for (char c : set2) {
            System.out.print(c+" ");
        }
    
        System.out.println("\n====不重复的字符========");
        for (char c : set3) {
            System.out.print(c+" ");
        }
    
    
    }
    

     

    使用Scanner从控制台读取一个字符串,统计字符串中每个字符出现的次数,要求使用学习过的知识完成以上要求 
    实现思路根据Set、List、Map集合的特性完成。

    public static void main(String[] args) {
        String str = "abcdeblmbac";
        System.out.println("原字符串:"+str);
    
        Map<Character,Integer> map = new HashMap<Character,Integer>();
        char[] cs = str.toCharArray();
    
        for (char c : cs) {
    
            if(map.containsKey(c)){
                Integer value = map.get(c);
                value++;
    
                map.put(c, value);
    
            }else{
                map.put(c, 1);
            }   
        }
        //遍历map
        Set<Character> set = map.keySet();
        for (Character c : set) {
            System.out.println(c+"出现了"+map.get(c)+"次");
        }
    }
    

    // 写一个Student类, 包含属性id[1-30), grade[1-6], score[0-100], 所有属性都是随机生成
    // 创建一个Set集合, 保存20个对象, 如果两个对象的id是一样的,则不允许添加.
    // 使用迭代器遍历集合,打印输出对象的信息, 并找出分数最高的同学和分数最低的同学, 最后打印输出最高分和最低分同学信息. 

    package Test;
    
    import java.util.*;
    // 写一个Student类, 包含属性id[1-30), grade[1-6], score[0-100], 所有属性都是随机生成
    // 创建一个Set集合, 保存20个对象, 如果两个对象的id是一样的,则不允许添加.
    // 使用迭代器遍历集合,打印输出对象的信息, 并找出分数最高的同学和分数最低的同学, 最后打印输出最高分和最低分同学信息.
    public class Test13 {
    
    	public static void main(String[] args) {
    		Set<Student> set = new HashSet<Student>();
    		for (; set.size() != 20;) {
    			int id = (int) (Math.random() * 29 + 1);
    			int grade = (int) (Math.random() * 6 + 1);
    			double score = (int) (Math.random() * 1001) / 10.0;
    			set.add(new Student(id, grade, score));
    		}
    		for (Student student : set) {
    			System.out.println(student);
    		}
    		System.out.println("---------------------------");
    		Student maxScoreStudent = null;
    		Student minScoreStudent = null;
    		Iterator<Student> iterator = set.iterator();
    		while (iterator.hasNext()) {
    			Student student = iterator.next();
    			if (maxScoreStudent == null) {
    				maxScoreStudent = student;
    				minScoreStudent = student;
    			}
    			if (student.getScore() > maxScoreStudent.getScore()) {
    				maxScoreStudent = student;
    			}
    			if (student.getScore() < minScoreStudent.getScore()) {
    				minScoreStudent = student;
    			}
    		}
    		System.out.println(maxScoreStudent);
    		System.out.println(minScoreStudent);
    	}
    }
    
    class Student implements Comparable<Student> {
    
    	private int id;
    	private int grade;
    	private double score;
    
    	public Student() {
    	}
    
    	public Student(int id, int grade, double score) {
    		super();
    		this.id = id;
    		this.grade = grade;
    		this.score = score;
    	}
    
    	public int getId() {
    		return id;
    	}
    
    	public void setId(int id) {
    		this.id = id;
    	}
    
    	public int getGrade() {
    		return grade;
    	}
    
    	public void setGrade(int grade) {
    		this.grade = grade;
    	}
    
    	public double getScore() {
    		return score;
    	}
    
    	public void setScore(double score) {
    		this.score = score;
    	}
    
    	@Override
    	public String toString() {
    		return "Student [id=" + id + ", grade=" + grade + ", score=" + score + "]";
    
    	}
    
    	public int compareTo(Student o) {
    		return (int) (this.score - o.score);
    	}
    
    }
    

     

    展开全文
  • 21天学通java6(教材源码+课后习题答案) 包括原书21章“程序清单”、“练习答案”。配套教材实例学习,相当不错!
  • JAVA面试练习题总汇

    2020-02-01 15:11:30
    练习01 1、前言 今天看到一位博主说的话感触超多:既然我没有别人聪明,那就做个比别人更努力的人吧。但是后来才发现,这个世界有一种可怕的存在:他既比你聪明,又比你勤奋。这就很尴尬了!所以,我还有什么资格...

    练习01

    1、前言

    今天看到一位博主说的话感触超多:既然我没有别人聪明,那就做个比别人更努力的人吧。但是后来才发现,这个世界有一种可怕的存在:他既比你聪明,又比你勤奋。这就很尴尬了!所以,我还有什么资格不努力了?

    因此我决定将自己所学的一个一个的练习,我知道什么是掌握了一门知识!就是当别人向你问起的时候你的脑海中已经有了关于这个知识的全部内容!概念,到实现,注意点等等!,但是可惜,我现在离开了教程就不会编程了,不,不应该把它叫做编程,叫抄写更加合适吧!但是学习就是从抄开始,所以就是每天我抄,我都要抄一定的数量,在不断的练习中感受它的原理感受的使用,然后总结,记录。让这些成为自己的,或者说把从书上抄改为从脑子里抄吧!(练习的题都是从百战里拿的)

    2、你学习编程的目的是什么?学习编程最快的方法是什么?

    答:学习编程的第一目的是因为自己大学学的计算机科学与技术,所以需要通过编程赚钱养家!其二当我正式开始程序员生涯的时候突然觉得生活不能碌碌无为,所以想找一样东西来证明自己的存在过!因此成为计算机大神就成为了我新的目标。学习编程的最快方法是什么?我一直来是使用视频,和上课来学习编程。但是,我发现此效率相当低!现在我的想法就是一边看书一边写代码验证是学习编程最快的方法。

    3、一个技术点怎才能算学会?

    答:从前我以为只要能默写出来就算会了,但是我现在不这么认为!先不说记忆代码多么费时间,主要应该是要理解知道为什么这个技术要这么用,这么写在程序中有何种用途,然后抽象的归纳每个步骤!在开始编写代码时将步骤通过注释标记然后按格子填空,我才觉得这是学会了。关键是解决的方案,而不是死代码。

    4、计算机语言的三代发展

    答:计算机语言目前大致分为3类,机器语言,汇编语言和高级语言。机器语言是直接通过10101二进制进行编写,而汇编语言是通过一些人类字符代替二进制进行编写,高级语言直接使用人理解的字符编写。其中的区别在于人理解的难度!

    5、JAVA语言的核心优势

    答:在我现在所接触过的语言中有C,C++,汇编语言以及JAVA,JAVA最大的特点在于它的跨平台,以及他的简单易学,编写WEB强大的好处。

    练习02

    6、JAVA得三个版本是什么?

    答:JAVA得三个版本分别是JAVASE、JAVAEE、JAVAME,分别解决桌面应用,企业网站、手机端等。

    7、JAVA跨平台怎么实现的?

    答:JAVA得跨平台是通过JVM实现的,JVM就是JAVA VIRTUAL MACHINE(Java虚拟机),简单的理解就是JAVA虚拟机就相当于一台电脑,然后你的JAVA代码是在JVM上跑,而不是真正在自己的电脑上跑,只要你的JDK版本一致,那你的代码不管是在WINDOS还是LINUX上跑都是一眼的在JVM上运行,所以就可以实现跨平台。

    8、JAVA语言是解释型还是编译型?

    https://blog.csdn.net/qzc70919700/article/details/72515022此人博客对此详细解释。说的非常清楚,我也相同的观点。

    JAVA都需要编译成.CLASS文件才能运行,但是它又是在JVM解释执行。所以说两种语言兼有。

    定义: 
    编译型语言:把做好的源程序全部编译成二进制代码的可运行程序。然后,可直接运行这个程序。 
    解释型语言:把做好的源程序翻译一句,然后执行一句,直至结束!
    区别: 
    编译型语言,执行速度快、效率高;依靠编译器、跨平台性差些。 
    解释型语言,执行速度慢、效率低;依靠解释器、跨平台性好。 

    我得认为是,还是编译型的。毕竟需要编译吗 。

    9、JDK、JRE、JVM的含义

    jdk,(java develope kit )java开发工具包 , jre(java run envoriment )java运行环境 jvm(java virtual machine) java虚拟机。

    10、JDK包含JRE吗?

    包含直接上图

    练习03

    11、DOS下自动补全的命令是那个?DOS下想查询以前使用的命令是那个?
    答:用table可以提示。以前直接用上方向键

    12、DOS下,dir代表什么意思?cd表示什么含义?

    答:dir代表展示带前所有的列表,cd代表进入某一个文件夹

    13、为什么采取JAVA_HOME的方式配置环境变量好?、

    答:更加方便,不用每次去JDK中调命令。

    14、一个JAVA源文件可以写多个CLASS吗?

    答:可以,但是只能有一个与文件名相同的类

    15、多行注释能不能嵌套使用。

    答:不行,亲测。

    练习04

    16、常用的进制有哪些?

    答:二进制、八进制、十进制、十六进制 二进制 101010101. 八进制    0开头 十进制就是平时得样子         十六进制     0x

    17、如何将10进制转换成2进制?

    答:通过短除法可以将10进制转换成2进制。关键点就是不断除以2.获得的余数反过来就是2进制。

    18、位、字节、字符。

    答:位(bit),是计算机里最基础的单位一位就是一个2进制 。1,0,0,1这种。字节是八个位称之位字节(byte).在英语中一字节就是一个英文,中文一个字占两字节。

    字符,和字节、位的含义不同。字符是代表符号,不是比如一字符的英文是一字节,一字符的中文是两字节。所以说字符是对应的符号,不是大小。

    19、标识符的符号。

    答:标识符由$ 和_数字,字母组成。数字不能开头。标识符用来标识变量,类等。

    20、java中有没有goto语句,有没有goto关键字。

    答:java中没有goto语句,但是goto有关键字。

    练习05

    21、byte、short、int 、long 占据字节数,标识的范围。

    答:byte 一字节   2^8次方。 -128~127.

    short 两字节 2^16次方 

    int 四字节  2的32次方 21亿

    long 八字节 2的64次方

    22、整形常数默认是什么类型的?

    答:Int型

    23、float、double占用几个字节?

    答:float 4 个 且定义float时需要加f,double 8个。

    24、java默认的浮点常量是什么类型?

    答:默认是dobule。如果申明是float需要加上f字母。

    25、如下写法哪些是不对的。

            byte b = 30;        //正确
            byte c = 500;        //超出了其表示范围,
            long d= 2343223;    //正确
            float f = 3.14;        //默认为dobule,需要加f

    练习06

    26、float能否比较?

    float d1 = 434f;
            float d2 = d1+1;
            if(d1==d2) {
                System.out.println("相等");
                }else {
            System.out.println("不相等");
                }

    可以比较不想等。

    27、字符型变量几个字节?这种写法对吗?char c = "d";

    答:    char c = "a";    //这种写法不对,需要用单引号

    28、布尔型变量占用的空间是一位还是一个字节?

    答:一个字节,一位就是一个二进制,一个字节是8个二进制。

    29、if(b==true)这种写法好不好?

    1.if(true==a)是两个变量之间的比较,if(a==true)是变量a是否为真的判断!不知这样说可否.. true是关键字,不是变量,不存在"两个变量"
     
    2.根据java代码的编写规则 是不允许写if(a==true)这样的代码的。 正确:if(a) or if(!a). 编码规范都推荐的if(a)或者if(!a)的方式,无论是sun还是IBM
    3.这两个区别我们推荐使用true==a,是为了防止有人漏写一个=号,因为你在写if(a==true)时,写成了if(a=true)错误是察觉不到的,例如在MyEclipse中 它不会给你错误的提示。直接判断就好了。

    30、常量的申明使用那个关键字.?

    答:final,代表最终的不可修改的;

    练习07

    31、常量的命名规范是?

    答:所有变量、方法、类名:见名知意

    变量、方法名:      首字母小写和驼峰原则      run(),runRun(),age   ageNew monthSalary

    常量:     大写字母和下划线:MAX_VALUE

    类名:     首字母大写和驼峰原则:Man,GoodMan

    32、驼峰原则?

    答:骆驼式命名法就是当变量名或函数名是由一个或多个单词连结在一起,而构成的唯一识别字时第一个单词以小写字母开始;从第二个单词开始以后的每个单词的首字母大写都采用大写字母。下划线命名法,每一个逻辑点用下划线分隔。

    33、使用Scanner接受键盘输入的是否一定要加import.java.util*?

    答:一定要加入这个包,因为这个类是存放于这个包中。

    34、引用类型是占几个字节?

    答:除了基本类型外,其他都是引用类型如:STRING;枚举;数组;类和接口等等。引用类型是保存的你堆中的地址。应该是16字节。

    35、算术运算符中类型提升是怎么回事?int a = 3; long b =3 ;a+b返回什么类型?

    答: 在计算a+b时,是按照long类型来进行的,计算机发现两个变量类型不一致时,会按照更复杂的类型的那个变量作为基准组织运算,a+b计算时,会将a转换成long型数据,按照long规则运算,得到long型的结果。

            int a= 3; 
            long b = 3; 
            long ab = a+b;
            //或者
            int ac = (int) (a+b);

    练习08 2019/12/29

    36、变量是什么

    答:1、我们通过变量来操作存储空间的值,变量就是指代的存储空间,存储空间的位置是确定的但是里面的数据是可变的。

           2、JAVA是强类型语言,所有的变量都需要申明类型才能创建。

           3、JAVA中变量是最基本的存储类型,需要有变量名,变量类型,作用域。

    格式:    type  varName  [=value] [{,varName[=value]}] 

    37、JAVA中有哪些运算符

     答:大致分七种类型的运算符。

     1、算数运算符:+,-,*,/,%,++,--。

     2、赋值运算符: = 。

     3、关系运算符:>,<,>=,<=,==,!=  instanceof。

     4、逻辑运算符:&&,||,!。

     5、位运算符:  &,|,^,~ , >>,<<,>>> (了解!!!)。

     6、条件运算符 ?:。

     7、扩展赋值运算符:+=,-=,*=,/=。

    38、JAVA中的乘幂处理。

    答:

    int a = 3^2;    //java中不能这么处理, ^是异或符号。
    
    double b = Math.pow(3, 2);

    39、JAVA中的三大结构。

    答:顺序结构、选择结构、循环结构。

    选择结构: if - else,if-elseif-else。

    循环结构:for(;;){},while(){},do-while(){}。

    练习09 2019/12/30

    40、Switch case语句中的穿透效应是什么.

    答:

    //反向利用case穿透
    public class TestSwitch {
        public static void main(String[] args){
            char c = 'a';
            int rand =(int) (26*Math.random());
            char c2 = (char)(c+rand);
            System.out.println(c2 + ":");
            switch (c2) {//如果是a e i o u 当中的一个会一直向下运行直到碰到break;
            case 'a':
            case 'e':
            case 'i':
            case 'o':
            case 'u':
                System.out.println("元音");
                break;
            case 'y':
            case 'w':
                System.out.println("半元音");
                break;
    
            default:
                System.out.println("辅音");
            }
        }
    }

    41、FOR循环(计算0到100之间的奇数和偶数的和).

    答:

    public class TestWhileFor {
    	public static void main(String[] args) {
    //计算0到100之间的奇数和偶数的和
    		int oddSum = 0;  //用来保存奇数的和
    		int evenSum = 0;  //用来存放偶数的和
    		for(int i=0;i<=100;i++){
    			if(i%2!=0){
    				oddSum += i;
    			}else{
    				evenSum += i;
    			}
    			
    		}
    		System.out.println("奇数的和:"+oddSum); 
    		System.out.println("偶数的和:"+evenSum); 
    		
    		System.out.println("#########################"); 
    	//用while和for循环输出1-1000之间能被5整除的数,并且每行输出3个
    		for(int j = 1;j<=1000;j++){
    			if(j%5==0){
    				System.out.print(j+"\t");
    			}
    			if(j%(5*3)==0){
    				System.out.println();
    			}
    		}
    		
    	}
    }

    42、打印九九乘法表 

    答:

    public class TestWhileFor02 {
        public static void main(String[] args) {
        for (int m = 1; m <= 9; m++) {
        for (int i = 1; i <= m; i++) {
        System.out.print(i + "*" + m + "=" + (i * m) + "\t");
    }
        System.out.println();
    }
     }
    }

    43、break语句和continue语句的区别。

    答:break 

    1. 在任何循环语句的主体部分,均可用break控制循环的流程。break用于强行退出循环,不执行循环中剩余的语句。(break语句也在switch语句中使用)

         continue

         2、continue 语句用在循环语句体中,用于终止某次循环过程,即跳过循环体中尚未执行的语句,接着进行下一次是否执行循环的判定。  

    44、JAVA中的值传递是什么东西 ?

    答:

    1. Java中进行方法调用中传递参数时,遵循值传递的原则:
          基本类型传递的是该数据值本身。引用类型传递的是对对象的引用,而不是对象本身。
    2. JAVA中只有值传递!

     

    45、递归是什么东西?怎么定义?

    答:1、  A方法调用B方法,我们很容易理解!递归就是:A方法调用A方法!就是自己调用自己,因此我们在设计递归算法时,一定要指明什么时候自己不调用自己。否则,就是个死循环!

    2、

    递归是一种常见的解决问题的方法,即把问题逐渐简单化。递归的基本思想就是“自己调用自己”,一个使用递归技术的方法将会直接或者间接的调用自己。

    利用递归可以用简单的程序来解决一些复杂的问题。比如:大多数排序使用的就是递归算法。

    递归结构包括两个部分:

        1.    定义递归头。解答:什么时候不调用自身方法。如果没有头,将陷入死循环。

        2.    递归体。解答:什么时候需要调用自身方法。

    练习10 2019/12/31

    46、API是什么?API文档又是什么?

    API:Application Programming Interface,应用程序编程接口。

    JDK为我们提供了很多类,如何使用这些类。我们可以通过查看API文档来获取信息。API文档就相当于我们学英语用的词典一样!

    47、JDK中常用的几个包是哪几个?请列举出来。

    1、  java.lang-包含一些Java语言的核心类,如String、Math、Integer、System和Thread,提供常用功能。

    2、  java.awt-包含了构成抽象窗口工具集(abstract window toolkits)的多个类,这些类被用来构建和管理应用程序的图形用户界面(GUI)。

    3、 java.net-包含执行与网络相关的操作的类。

    4、java.io-包含能提供多种输入/输出功能的类。

    5、java.util-包含一些实用工具类,如定义系统特性、使用与日期日历相关的函数。

    48、静态导入是什么东西?有什么含义如何使用。

     static  import静态导入(JDK 1.5后增加, 了解!):

        静态导入的作用:用于导入指定类的静态属性

    如何使用

        import static java.lang.Math.*;//导入Math类的所有静态属性

        import static java.lang.Math.PI;//导入Math类的PI属性

    然后,我们可以在程序中直接使用:System.out.println(PI);

    49、Scanner类导入以及使用。

      import java.util.Scanner;
    
     /**
    
     * 测试import导入Scanner类,以及Scanner类的使用,如何接收键盘的输入。
    
     */
    
    public class TestScanner {
    
        public static void test01(){
    
        Scanner s = new Scanner(System.in);
    
        String str = s.next();  //程序运行到next会阻塞,等待键盘的输入!
    
        System.out.println("刚才键盘输入:"+str); 
    
    }
    
    public static void test02(){
    
        Scanner s = new Scanner(System.in);
    
        System.out.println("请输入一个加数:"); 
    
        int a = s.nextInt();
    
        System.out.println("请输入被加数:");
    
        int b = s.nextInt();
    
        int sum =a+b;
    
        System.out.println("计算结果,和为:"+sum); 
    
    }
    
    public static void main(String[] args) {
    
        test02();
    
    }
    
    }

    50、什么是面向对象?什么是面向过程 ?

    面向过程:

    面向过程的语言也称为结构化程序设计语言,是高级语言的一种。在面向过程程序设计中,问题被看作一系列需要完成的任务,函数则用于完成这些任务,解决问题的焦点集中于函数。其概念最早由E.W.Dijikstra在1965年提出,是软件发展的一个重要里程碑。它的主要观点是采用自顶向下、逐步求精的程序设计方法,使用三种基本控制结构构造程序,即任何程序都可由顺序、选择、循环三种基本控制结构构造。

    面向对象:

    面向对象(Object Oriented)是软件开发方法。面向对象的概念和应用已超越了程序设计和软件开发,扩展到如数据库系统、交互式界面、应用结构、应用平台、分布式系统网络管理结构、CAD技术、人工智能等领域。面向对象是一种对现实世界理解和抽象的方法,是计算机编程技术发展到一定阶段后的产物。

    面向对象是相对于面向过程来讲的,面向对象方法,把相关的数据和方法组织为一个整体来看待,从更高的层次来进行系统建模,更贴近事物的自然运行模式。 

    练习11 2020/1/3

    51、 栈、堆、方法区的概念。

    • 栈是系统分配的一段连续的内存空间,速度快。
    • JAVA中局部变量放置于栈中。
    • 栈再每个线程中是各自私有的,不能实现线程之间的共享

    • 放置new 出来的对象。
    • 堆是一个不连续的内存空间,分配灵活,速度慢。读取速度。

    方法区

    •     1.    被所有线程共享!

    •     2.    用来存放程序中永远是不变或唯一的内容。(类代码信息、静态变量、字符串常量)

    52、 JAVA中引用类型是什么?

     

    1.    java中,除了基本数据类型之外的其他类型称之为引用类型。
    2.  java中的对象是通过引用来操作的。(引用:reference)引用指的就是对象的地址!

    53、 JAVA中属性是什么东西?

     属性(field,或者叫成员变量)

        1.    属性用于定义该类或该类对象包含的数据或者说静态属性。

        2.    属性作用范围是整个类体。

        3.    属性的默认初始化:

        在定义成员变量时可以对其初始化,如果不对其初始化,Java使用默认的值对其初始化。(数值:0,0.0   char:\u0000,  boolean:false,  所有引用类型:null)  

        4.    属性定义格式:

    [修饰符]  属性类型  属性名 = [默认值] 

    54、 JAVA中构造方法是什么?怎么实现?作用是什么?

    • 构造方法是JAVA中的一种特殊的方法,没有返回值,和类名相同。 
    • [修饰符] 类名(形参列表){

      //n条语句

      }

    •     1.    通过new关键字调用!!

          2.    构造器虽然有返回值(返回该类的对象),但是不能定义返回类型 (返回值的类型肯定是本类),不能在构造器里调用return。

          3.    如果我们没有定义构造器,则系统会自动定义一个无参的构造函数。如果已定义则编译器不会添加!

          4.    构造器的方法名必须和类名一致!

    • 构造器用于构造该类的实例

    55、方法的重载(overload),构造方法的重载的异同

     

      方法的重载是指一个类中可以定义有相同的名字,但参数不同的多个方法。 调用时,会根据不同的参数表选择对应的方法。

         方法调用时,匹配离得最近的类型

        不同的含义:类型,个数,顺序不同

        只有返回值不同不构成方法的重载(int a(String str){}, void  a{int i},  调用:a(),谁能告诉我是调哪个方法?)

        只有形参的名称不同,不构成方法的重载

        与普通方法一样,构造方法也可以重载

    练习12 2019/1/6

    56、static关键字用来干什么。

    1. 在类中,用static声明的成员变量是静态成员变量。
    2. 静态成员变量为该类的公用变量,被类的所有实例公用。在类载于的时候显示的初始化。
    3. 对于该类来讲,该类的静态变量就只有一份,被所有的该类对像公用。
    4. 可以使用 对象.类属性  调用 static声明的成员变量。不过通常我们用 类名.类属性 来进行调用。
    5. 用static声明的方法为静态方法 .不需要new 对象就能调用对应的静态方法 。
    6. 在调用该方法时,不会将对象的引用传递给它,所以在static方法中不可访问非static的成员。

    57、this关键字用来干什么?

     

    1、普通方法中,this总是指向调用该方法的对象。

    2、构造方法中,this总是指向正要初始化的对象。

    3、this常用的使用方法.让类中的方法啊,访问类的另一个方法或者属性。使用this关键字调用重载构造方法。避免相同的初始化代码,只能在构造方法中用,并且必须位于构造方法的第一句。

    4、   this不能用于static方法!(this指向当前对象,static方法跟对象没有一毛钱的关系)

    58、方法的重写(override)

    1. 方法的重载一定是发生在继承。
    2. 在子类中可以根据需要对从基类中继承来的方法进行重写。

    3.  重写方法必须和被重写方法具有相同方法名称、参数列表和返回类型。(和重载明显不同)

    4.  重写方法不能使用比被重写方法更严格的访问权限。(由于多态)

    59、方法重写和方法重载的区别

    1. 多人问重写和重载什么区别? 他们两个完全是两回事。除了名字都带一个“重”字之外。

    2. 方法重载指的是:同一个类中,一个方法名对应了多个方法(形参列表不同)

    3.  

      方法的重写指的是:子类重写了父类的方法!

    60、Object类

    1. 在JAVA中Object 是所有类基类。
    2.   如果在类的声明中未使用extends关键字指明其基类,则默认基类为Object类 

           public class Person {

              ...

           }等于

    3. public class Person extends Object {

      ...

      }

    练习12 2019/1/7

    61、Object中所有的方法。

    1. toString方法

              获取当前类的名字,以及@用哈希码获取内存地址。

         2、equals方法

              

              在Object的equals方法是指的当前对象和这个本身方法的对象是不是同一个对象。

             String 类中重写了这个方法。

          

    62、Super关键字如何使用,又何作用?

    1. Super的含义:

      super是直接父类对象的引用。可以通过super来访问父类中被子类覆盖的方法或属性。

      除了Object类之外其他所有类的构造方法第一句总是super(…)

      任何类的构造方法中,若是构造方法的第一行代码没有显式的调用super(...);那么Java默认都会调用super(); 所以你这里的super(); 加不加都无所谓。

    63、JAVA中继承和组合的共同点以及不同点。

    1. 继承和组合的共同点都是可以实现代码复用。
    2. 继承是 is-a的关系,比如 A类继承了B类,可以看成A就是B类的一种。
    3. 组合是has-a的关系,比如A类组合了B类,可以看成A类中含有B类的一些方法。

    继承就是 extends就完成了。组合 实际上就是 在A类的类方法中调用B类的方法 。

    例如 。

    class A {
        
        public void run (){
            System.out.println("我是A类的run方法");
        }
    }
    
    class B{
         A a  = new A();
        public void run (){
            a.run;
        }
    }

    64、final的用法

    1. final可以用于修饰变量。当final修饰的变量后,改变量不可再次改变。即初始化一次后就不能再次赋值。也就是一个变量变成了常量。
    2. final可以修饰方法,方法不可以被子类重写。但是可以重载!简单来说就是不能去修改,被final修饰的类。
    3. final也可以修饰类,被final修饰的类不能被继承!是最终类。
       

    65、封装是啥东西?

    1. 面向对象的语言有3大特性 ,继承,多态,和封装。
    2. 封装的含义,作用,以及为什么需要封装。

    1、为什么要用封装了,例如我们开车只需要会开车这个技能就可以,车的内部构造或者行为是如何的我们并不需要。又比如收音机我们只需要开关即可,如何实现一个收音机我们并不需要去关心。

    上述为白话,说的更加抽象一点的话是软件设计推崇“高内聚,低耦合” 高内聚就是类的内部数据操作细节自己完成,不允许外部干涉;低耦合:仅暴露少量的方法给外部使用。

    2、含义,作用:

    便于调用者调用。

    良好的封装,便于修改内部代码,提高可维护性。

    良好的封装,可进行数据完整性检测,保证数据的有效性。

    3、实现:

    通过访问控制符进行封装的实现。

     

    同一个类

    同一个包中

    子类

    所有类

    private

    *

     

     

     

    default(即不加修饰符的时候)

    *

    *

     

     

    protected

    *

    *

    *

     

    public

    *

    *

    *

    *

    1.    属性一般使用private.(除非本属性确定会让子类继承并且使用)

    提供相应的get/set方法来访问相关属性. 这些方法通常是public,从而提供对属性的读取操作。  (注意:boolean变量的get方法是用:is开头!)

    2.    一些只用于本类的辅助性方法可以用private,希望其他类调用的方法用public。

    练习13 2020/1/8

    66、多态实现以及意义。

    1. 多态是面向对象的语言3个特征之一。
    2. 多态最主要的重要的一个作用就是实现动态编程。换种理解就是代码并不是编写的时候就决定好了,而是运行的时候才被动态的决定。这对于大型系统来说能提高系统的灵活性和扩展性。
    3. 多态可以让我们不去关心对象具体是什么类型,就可以去调用该对象得方法。
    4. 为什么需要多态了,因为我们需要不同得类对同一消息做出不同得反应。
    5. JAVA中如何实现多态。

      多态的使用要点

          1.    多态是方法的多态,属性没有多态性。

          2.    编写程序时,如果想调用运行时类型的方法,只能进行类型转换。不然通不过编译器的检查。但是如果两个没有关联的类进行强制转换,会报:ClassCastException。 比如:本来是狗,我把它转成猫。就会报这个异常。

          3.    多态的存在要有3个必要条件:要有继承,要有方法重写,父类引用指向子类对象.

    6. 静态的多态指的方法重载,动态的多态指的是方法重写。

    67、对象的强制转型

    1. 为什么需要强制转换类型?   

    2.  引用变量只能调用它编译类型的方法,不能调用它运行类型的方法。这时,我们就需要进行类型的强制转换!

    3.   一个父类的引用类型变量可以“指向”其子类的对象。

       一个父类的引用不可以访问其子类对象新增加的成员(属性和方法)。

      可以使用 引用 变量 instanceof 类名 来判断该引用型变量所“指向”的对象是否属于该类或该类的子类。

      子类的对象可以当作基类的对象来使用称作向上转型(upcasting),反之称为向下转型(downcasting)

    68、抽象方法的使用和作用

    1.     只声明了方法,同时使用了abstract修饰,没有方法体!必须要子类来重写!
    2.     有抽象方法的类,必须声明为抽象类。
    3.     

      抽象类的使用要点

          1.    通过抽象类,可以避免子类设计的随意性。

          2.    有抽象方法的类只能定义能抽象类

          3.    抽象类不能实例化,及不能用new来实例化抽象类。

          4.    抽象类可以包含属性、方法、构造方法。但是构造方法不能用来new实例,只能用来被子类调用。

          5.    抽象类只能用来继承。

          6.    抽象方法必须被子类实现。

    69、接口的意义与作用?

    1.  接口:简单就是规范。
    2.  普通类:只有具体实现

       抽象类:具体实现和规范(抽象方法) 都有!

       接口:只有规范!

    3. 为什么需要接口?

              接口就是比“抽象类”还“抽象”的“抽象类”,可以更加规范的对子类进行约束。全面地专业地实现了:规范和具体实现的分离。

             抽象类还提供某些具体实现,接口不提供任何实现,接口中所有方法都是抽象方法。接口是完全面向规范的,规定了一批类具有的公共方法规范。

       从接口的实现者角度看,接口定义了可以向外部提供的服务。

       从接口的调用者角度看,接口定义了实现者能提供那些服务。

       接口是两个模块之间通信的标准,通信的规范。如果能把你要设计的系统之间模块之间的接口定义好,就相当于完成了系统的设计大纲,剩下的就是添砖加瓦的具体实现了。大家在工作以后,做系统时往往就是使用“面向接口”的思想来设计系统。

     

    如何定义接口?

    格式:

    [访问修饰符]  interface 接口名   [extends  父接口1,父接口2…]  {

    常量定义

    方法定义

    }

    访问修饰符:只能是public或默认。

    接口名:和类名采用相同命名机制

    extends:接口可以多继承

    常量:接口中的属性只能是常量,总是:public static final 修饰。不写也是。

    方法:接口中的方法只能是:public abstract。 省略的话,也是public abstract.

    接口使用要点

        1.    子类通过implements来实现接口中的规范

        2.    接口不能创建实例,但是可用于声明引用变量类型。

        3.    一个类实现了接口,必须实现接口中所有的方法,并且这些方法只能是public的。

        4.    接口中只能包含静态常量、抽象方法,不能有普通属性、构造方法、普通方法。

        5.    常量必然是:public static final。  我们不加这些修饰符,也是这样。

        6.    方法必然是:public abstrac。  我们不加这些修饰符,也是这样。

        7.    接口完全支持多继承。和类的继承类似,子接口扩展某个父接口,将会获得父接口中所定义的一切。

    70、值传递和引用传递

    1. JAVA只有值传递,基本类型直接传值。引用类型传递的地址。

    练习14 2020/1/9

    71、内部类的含义以及实现。

    1. 首先内部类是什么东西。

               简单来说内部类就是在一个类里面在创建一个类,这就是内部类。一般来说我们把类作为一个独立的单元,但是有的情况下我们把一个类放到另一个类里面去。这就是内部类。

        2.内部类的作用?

              1、首先内部类提供了更好的封装,内部类只能够让外部类访问。其他的类都无法直接进行访问(包括同一包内的其他类)。

              2、内部类实际上相当于外部类的一个成员,因此内部类可以直接访问外部类的私有私有属性,但是外部类不能访问内部类的属性。(奇怪的设定我搞不清为啥要这样干。)

             3、一般来说只有当一个类只为另一个类提供服务得时候使用内部类,感觉挺鸡肋。一个新的答案(  在项目中,需要多重继承,如果是两个接口,那么好办,接口支持多重继承。 如果是两个类呢?这时只有使用内部类了。)

        3.内部类的分类。

             1、  成员内部类

             2、  匿名内部类

             3、  静态内部类

             4、  局部内部类

    72、String 类的一些基本使用?

    1.  Java没有内置的字符串类型,而是在标准Java类库中提供了一个预定义的类String,每个用双引号括起来的字符串都是String类的一个实例。JAVA.LANG.STRING.

    2.     String e = “” ; // an empty string
          String greeting = “Hello World”;

       

         3.JAVA可以用+号进行链接两个字符串

     符号“+”把两个字符串按给定的顺序连接在一起,并且是完全按照给定的形式。 当“+”运算符两侧的操作数中只要有一个是字符串(String)类型,系统会自动将另一个操作数转换为字符串然后再进行连接。

    String s1 = “Hello”;String s2 = “World!”;
    String s = s1 + s2; //HelloWorld!
    
    
    
    int age = 18;
    String s = "age is" + age;  //s赋值为age is 18

     

     

    73、字符串比较相等的方法。

    1.     equals方法用来检测两个字符串内容是否相等。如果字符串s和t内容相等,则s.equals(t)返回true,否则返回false.

         s和t既可以是字符串变量,也可以是字符串常数,例如: “Hello”.equals(t);

         要测试两个字符串除了大小写区别外是否是相等的,需要使用equalsIgnoreCase方法,例如:

             “Hello”.equalsIgnoreCase(“hellO”);//true

         判断字符串是否相等不要使用“==”

    74、数组概述和特点

    1.   数组的定义:数组是相同类型数据的有序集合. 数组描述的是相同类型的若干个数据,按照一定的先后次序排列组合而 成。其中,每一个数据称作一个数组元素,每个数组元素可以通过一个下标来访问它们。 数组的四个基本特点:
    2.     1.    其长度是确定的。数组一旦被创建,它的大小就是不可以改变的。 

          2.    其元素必须是相同类型,不允许出现混合类型。

          3.    数组中的元素可以是任何数据类型,包括基本类型和引用类型。

          4.    数组变量属引用类型,数组也可以看成是对象,数组中的每个元素相当于该对象的成员变量。数组本身就是对象,Java中对象是在堆中的,因此数组无论保存原始类型还是其他对象类型,数组对象本身是在堆中的。

    75、数组的声明。

    1. n    声明(一维数组的声明方式有两种)

      type[]   arr_name;(推荐使用这中方式)

      type   arr_name[]; 

      注:

          1.    声明的时候并没有实例化任何对象,只有在实例化数组对象时,JVM才分配空间,这时才与长度有关。因此,声明数组时不能指定其长度(数组中元素的个数),例如: int a[5]; //非法

          2.    声明一个数组的时候并没有数组被真正的创建。

          3.    构造一个数组,必须指定长度。

    练习15 2020/1/10

    76、JAVA二维数组初始化的3种类型以及实现。

    1、使用大括号直接赋值,适合已经确定知道数组元素的情况

    2、给定二维数组的大小

    3、数组第二维的长度可变化,未改变

    package test01;
    
    import java.util.Random;
    
    public class TestInitizationArrary {
    
        public static void main(String[]args){
            //直接初始化二维数组。
            //静态初始化  数组初始化的时候第一个要点。声明的时候是不能直接赋值大小。
            int[][] arrary01 = {{2,3},{4,2}};
            for(int i = 0 ; i <arrary01.length ; i++) {
                for(int j = 0 ; j < arrary01[i].length ; j++)
                    System.out.print(arrary01[i][j]);
    
                System.out.println();
            }
    
            System.out.println("-------------分割线 动态初始化------------------");
    
            //动态初始化
            int[][] arrary02 = new int[3][4];
            int cont =0;
            for(int i = 0 ; i < arrary02.length ; i++) {
                for (int j = 0; j < arrary02[i].length; j++) {
                    arrary02[i][j] = cont;
                    cont++;
                }
            }
            for(int i = 0 ; i < arrary02.length ; i++) {
                for (int j = 0; j < arrary02[i].length; j++) {
                    System.out.print(arrary02[i][j]);
                }
                System.out.println();
            }
    
            System.out.println("-------------分割线 动态初始化列不顶------------------");
    
            int[][] arrary03 = new int[4][];
            int count = 1 ;
            for(int i = 0 ; i < arrary03.length ; i++){
                //每次给一个列进行创建新的值
                //Random random= new Random();
                //int sjs = random.nextInt(100);
                arrary03[i] = new int[count];
                for(int j = 0 ; j < arrary03[i].length;j++){
    
                    arrary03[i][j]=count;
                }
                count++;
            }
    
            for(int i = 0 ; i < arrary03.length ; i++) {
                for (int j = 0; j < arrary03[i].length; j++) {
                    System.out.print(arrary03[i][j]);
                }
                System.out.println();
            }
        }
    }
    

    77、String类常用方法。

    1. 首先我们已经认识到String类是最终类,不可变的。
    2. 常用的方法有一下几类。

             1、创建并返回一个新的String对象:concat, replace,  substring, toLowerCase, toUpperCase, trim.

             2、提供查找功能的有关方法: endsWith, startsWith, indexOf,,lastIndexOf.

             3、 提供比较功能的方法: equals, equalsIgnoreCase,  compareTo

    78、StringBuilder与StringBuffer的区别?

    1. String不能修改,所以我们在进行多次修改字符串的时候我们就是用StringBuilder和StringBuffer。
    2. StringBuilder可变字符串,线程不太安全,但效率高,推荐使用。单线程的时候建议使用。
    3. StringBuffer可变字符串,线程安全,但效率低,不推荐使用。

           StringBuilder 与StringBuffer的区别,StringBuilder与String的区别。

    1)StringBuilder效率高,线程不安全,StringBuffer效率低,线程安全。

    2)String是不可变字符串,StringBuilder是可变字符串。为什么有这样的差异,可以深入源码去解析,比如String类内的 priver final  char  value[] 等方法的原因。

    3)如果是简单的声明一个字符串没有后续过多的操作,使用String,StringBuilder均可,若后续对字符穿做频繁的添加,删除操作,或者是在循环当中动态的改变字符穿的长度应该用StringBuilder。使用String会产生多余的字符串,占用内存空间。

    79、增强型FOR循环。

    public class TestForInter {
        public static void main(String[] args){
            //数组是引用类型
            int[] list = new int[10];
            for(int i = 0 ; i < 10 ;i++)
                list[i]=i;
    
            for(int l:list){
                System.out.println(l);
            }
        }
    }

     

    80、自动拆箱和装箱。

    1.  就是将基本类型和包装类进行自动的互相转换。

          JDK5.0后,将自动装箱/拆箱引入java中。
      自动装箱的过程:每当需要一种类型的对象时,这种基本类型就自动地封装到与它相同类型的包装中。
      自动拆箱的过程:每当需要一个值时,被装箱对象中的值就被自动地提取出来,没必要再去调用intValue()和doubleValue()方法。

    2.  

      自动装箱与拆箱的功能事实上是编译器来帮您的忙,编译器在编译时期依您所编写的语法,决定是否进行装箱或拆箱动作。例如:

      Integer i = 100;

      相当于编译器自动为您作以下的语法编译:

      Integer i = new Integer(100);

      所以自动装箱与拆箱的功能是所谓的“编译器蜜糖”(Compiler Sugar),虽然使用这个功能很方便,但在程序运行阶段您得了解Java的语义。例如下面的程序是可以通过编译的:

      Integer i = null;

      int j = i;

      这样的语法在编译时期是合法的,但是在运行时期会有错误,因为这种写法相当于:

      Integer i = null;

      int j = i.intValue();

      null表示i没有参考至任何的对象实体,它可以合法地指定给对象参考名称。由于实际上i并没有参考至任何的对象,所以也就不可能操作intValue()方法,这样上面的写法在运行时会出现NullPointerException错误。

    练习16 2020/1/11

    81、Date类的常用方式?

    1. 在JAVA标准类库中包含一个时间类。精确的时间到毫秒
    2.   Date(long date) 分配 Date 对象并初始化此对象,以表示自从标准基准时间(称为“历元(epoch)”,即 1970 年 1 月 1 日 00:00:00 GMT)以来的指定毫秒数。 

    3. 时间类常用的几个方法 long getTime();返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。

    4.     boolean after(Date when) 测试此日期是否在指定日期之后。 

    5.   boolean before(Date when)  测试此日期是否在指定日期之前。

    6. public class TestDate {
          public static void main(String []  args){
              //Date类用常用的几种方法
              Date date = new Date();
              //最最常用的getTime();
              System.out.println(date.getTime());
              System.out.println(System.currentTimeMillis());
              Date date2 = new Date(234234);
              System.out.println(date2.getTime());
              date2.setTime(2);
              System.out.println(date2.getTime());
              System.out.println(date.before(date2));
              System.out.println(date.after(date2));
          }
      }

       

    7. String toString(),把Date对象转换为一下形式的String.

       

    82、DateFormat和SimpleDateFormat类  

    1. DateFormat是个抽象类,SimpleDateFormat类继承了该类,我们一般使用它。用于格式话时间。
    2. public class TestSimpleFormatDate {
          //关系 ,日历类,时间类,日期格式类
          public static void main(String [] args) throws ParseException {
              SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-mm-dd");
              simpleDateFormat.format(new Date());
              System.out.println(simpleDateFormat.format(new Date()));
              //直接调用
              System.out.println(new SimpleDateFormat("hh:mm:ss").format(new Date()));
      
              //上面是 将日期改成字符串 。
              //------------------------------
              //下面是将字符串改成日期
              // 将符合指定格式的字符串转成成时间对象.字符串格式需要和指定格式一致。
              String time = "2020-1-11";
              Date date = simpleDateFormat.parse(time);
              System.out.print(date.getTime());
              System.out.println(date);
      
          }
      }

       

    83、Calendar 日历类   

    1. Calendar 类是一个抽象类,它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等 日历字段之间的转换提供了一些方法,并为操作日历字段(例如获得下星期的日期)提供了一些方法。瞬间可用毫秒值来表示,它是距历元(即格林威治标准时间 1970 年 1 月 1 日的 00:00:00.000,格里高利历)的偏移量。 

    2. GregorianCalendar 是 Calendar 的一个具体子类,提供了世界上大多数国家/地区使用的标准日历系统。注意月份的表示,一月是0,二月是1,以此类推,是12月是11。因为大多数人习惯于使用单词而不是使用数字来表示月份,这样程序也许更易读,父类Calendar使用常量来表示月份:JANUARY, FEBRUARY,等等。

    84、File类的常用方法

    ava.io.File类:文件和目录路径名的抽象表示形式。

            File类的常见构造方法:

       public File(String pathname)

      以pathname为路径创建File对象,如果pathname是相对路径,则默认的当前路径在系统属性user.dir中存储。

    2 File的静态属性String separator存储了当前系统的路径分隔符。 

    3 通过File对象可以访问文件的属性。
        public boolean canRead()     public boolean canWrite()
        public boolean exists()      public boolean isDirectory()
        public boolean isFile()      public boolean isHidden()
        public long lastModified()   public long length()
        public String getName()      public String getPath()

    4 通过File对象创建空文件或目录(在该对象所指的文件或目录不存在的情况下)。

        public boolean createNewFile()throws IOException

        public boolean delete() 

    public boolean mkdir(), mkdirs()

    85、枚举的意义

    1、枚举类型:

    2、 只能够取特定值中的一个

    3、使用enum关键字

    4、 所有的枚举类型隐性地继承自 java.lang.Enum。(枚举实质上还是类!而每个被枚举的成员实质就是一个枚举类型的实例,他们默认都是public static final的。可以直接通过枚举类型名直接使用它们。)

    5、强烈建议当你需要定义一组常量时,使用枚举类型

    6、 尽量不要使用枚举的高级特性,事实上高级特性都可以使用普通类来实现,没有必要引入复杂性!

    练习17 2020/1/13

    86、异常的概念。

    JAVA是采用面向对象的方式来处理异常。

    1.     抛出异常:在执行一个方法时,如果发生异常,则这个方法生成代表该异常的一个对象,停止当前执行路径,并把异常对象提交给JRE。

    2.   捕获异常:JRE得到该异常后,寻找相应的代码来处理该异常。JRE在方法的调用栈中查找,从生成异常的方法开始回溯,直到找到相应的异常处理代码为止。

    87、Error和Exception的区别。

    1. JDK 中定义了很多异常类,这些类对应了各种各样可能出现的异常事件,所有异常对象都是派生于Throwable类的一个实例。如果内置的异常类不能够满足需要,还可以创建自己的异常类。
    2. Error类层次描述了Java运行时系统内部错误和资源耗尽错误。这类错误是我们无法控制的,同时也是非常罕见的错误。所以在编程中,不去处理这类错误。

      Error表明系统JVM已经处于不可恢复的崩溃状态中。我们不需要管他。

      打开JDK的:java.lang.error,查看他的所有子类。

       Error和Exception的区别:

         我开着车走在路上,一头猪冲在路中间,我刹车。这叫一个异常。

      我开着车在路上,发动机坏了,我停车,这叫错误。系统处于不可恢复的崩溃状态。发动机什么时候坏?我们普通司机能管吗?不能。发动机什么时候坏是汽车厂发动机制造商的事。

    3. Exception

      所有异常类的父类,其子类对应了各种各样可能出现的异常事件。 

      n    Runtime Exception(unchecked Exception)

          出现RuntimeException就一定是你的问题,可以不捕获,因为小心点这些异常是可以避免的。 派生于RuntimeException的异常。是一类特殊的异常,如被 0 除、数组下标超范围等,其产生比较频繁,处理麻烦,如果显式的声明或捕获将会对程序可读性和运行效率影响很大。因此由系统自动检测并将它们交给缺省的异常处理程序(用户可不必对其处理)。这类异常通常是由编程错误导致的,因为只有小心点,这些异常都是可以避免的,所以在编写程序时,并不要求必须使用异常处理机制来处理这类异常,所有这类异常都继承自java.lang.RuntimeException。

      注意:RuntimeException这个名字很容易让人产生错误印象。事实上,我们这里讨论的所有Error、Exception都是运行时发生的。

    88、TRY CATCH 的使用以及Finally的执行顺序。

    1. try块

           try语句指定了一段代码,该段代码就是一次捕获并处理的范围。在执行过程中,当任意一条语句产生异常时,就会跳过该段中后面的代码。代码中可能会产生并抛出一种或几种类型的异常对象,它后面的catch语句要分别对这些异常做相应的处理

      一个try语句必须带有至少一个catch语句块或一个finally语句块 。。

       注:当异常处理的代码执行结束以后,是不会回到try语句去执行尚未执行的代码。

    2.  

        a)    每个try语句块可以伴随一个或多个catch语句,用于处理可能产生的不同类型的异常对象。

        b)    常用方法:

         toString ( )方法,显示异常的类名和产生异常的原因

        getMessage( )  方法,只显示产生异常的原因,但不显示类名。

        printStackTrace( )  方法,用来跟踪异常事件发生时堆栈的内容。

       这些方法均继承自Throwable类 

        c) Catch捕获异常时的捕获顺序:  i.    如果异常类之间有继承关系,在顺序安排上需注意。越是顶层的类,越放在下面。再不然就直接把多余的catch省略掉。

    3. 执行顺序: 

      1.    执行try,catch , 给返回值赋值

      2.    执行finally

      3.    return 

    89、throws子句 

    1.  

      当Checked Exception产生时,不一定立刻处理它,可以再把异常Throws出去。

          在方法中使用try-chatch-finally由这个方法处理异常。在一些情况下,当前方法并不需要处理发生的异常,而是向上传递给调用它的方法处理。

      如果一个方法中可能产生某种异常,但是并不能确定如何处理这种异常,则应根据异常规范在方法的首部声明该方法可能抛出的异常。

      如果一个方法抛出多个已检查异常,就必须在方法的首部列出所有的异常,之间以逗号隔开。

      典型代码(先不敲!):

    90、

    1.  

    2020/1/15

    91、Collection集合关系图

    .Collection接口

            Collection 表示一组对象,他是集中收集的意思,就是把一组数据收集起来,Collection接口的两个子接口Set,List:

            Set中的数据没有顺序,不可以重复。

            List中的数据有顺序,可以重复。

            Collection接口中定义的方法:

    92、ArrayList和LinkedList的区别

    1. ArrayList是底层用数组实现的List,特点是:查询效率高 ,增删效率低,不安全。
    2. :底层是双向链表实现的List,特点是:查询效率低,增删效率高,线程不安全。

    3.     Vector:底层用数组实现的List,特点:线程安全.

       如何选用

      

        线程安全用Vector.

        线程不安全,查找较多用ArrayList,增加或删除元素较多用LinkedList.

    93、模仿斗地主

    public class TestCollections {
        public static void main(String [] args){
            List<Integer> cards = new ArrayList<Integer>();
            //向数组添加卡片
            for(int i = 0 ; i < 54 ; i++){
                cards.add(i);
            }
            Collections.shuffle(cards);
            List<Integer> p1 = new ArrayList<Integer>();
            List<Integer> p2 = new ArrayList<Integer>();
            List<Integer> p3 = new ArrayList<Integer>();
            List<Integer> last = new ArrayList<Integer>();
            for(int i=0;i<51;i+=3){
                p1.add(cards.get(i));
                p2.add(cards.get(i+1));
                p3.add(cards.get(i+2));
            }
            //最后三张为底牌
            last.add(cards.get(51));
            last.add(cards.get(52));
            last.add(cards.get(53));
    
    
            System.out.println("第一个人:"+p1);
            System.out.println("第二个人:"+p2);
            System.out.println("第三个人:"+p3);
            System.out.println("底牌为:"+last);
        }
    }
    

    94、Hashtable与HashMap区别:

    1. Hashtable线程安全,同步,效率低下。HashMap线程不安全,不同步,效率相对高
    2. Hashtablle的父类是Dictionary,HashMap的父类是AbstractMap。
    3. HashMap的键可以一个为NULL,值可以多个为NULL.Hashtable,键和值都不能为NULL. 

     

    95、Properties

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

    展开全文
  • [attach]889120[/attach] [attach]889121[/attach] [attach]889122[/attach] [attach]889123[/attach] [attach]889124[/attach] [attach]889126[/attach] [attach]889127[/attach] [attach]889128[/attach......
    [attach]889120[/attach]
    [attach]889121[/attach]
    [attach]889122[/attach]
    [attach]889123[/attach]
    [attach]889124[/attach]
    [attach]889126[/attach]
    [attach]889127[/attach]
    [attach]889128[/attach]
    [attach]889129[/attach]
    [attach]889125[/attach]
    《21天学通Java》是Java语言的入门教程,由浅入深,循序渐进地讲授如何使用Java语言进行程序开发。全书内容包括Java开发环境、Java基本语法知识、Java面向对象特点、Java界面开发,以及Java数据库开发和网络编程开发。为了便于读者学习,《21天学通Java》最后一章对一个完整学生管理系统进行了分析。具体讲解了学生模块和老师模块,以及其他各个模块的功能分析。
    《21天学通Java》旨在为Java语言的初学者和大中专学生提供易于入门,便于全面了解和掌握Java编程技术的教辅资料,同时对有一定经验的Java编程者和学习者也有一定的参考价值。《21天学通Java》附赠DVD光盘1张,内容包括电子教案(PPT)、源代码及各章习题答案。
    本教程共分为21章电子教案PPT,配有21章的课后习题及答案以及21章的源代码,每天一章,循序渐进。让你成为java高手不在是梦!由于附件较多,附上前10章,剩余11章请您自行下载,本人亲自上传,转载请注明出处!
    下载地址:[url]http://down.51cto.com/data/418401[/url]
    展开全文
  •  import java.io.BufferedReader;import java.io.BufferedWriter;import java.io.FileReader;import java.io.FileWriter;import java.io.IOException;import java.util.ArrayList;import jav...

    package com.czz.text03;

     

    import java.io.BufferedReader;

    import java.io.BufferedWriter;

    import java.io.FileReader;

    import java.io.FileWriter;

    import java.io.IOException;

    import java.util.ArrayList;

    import java.util.Scanner;

     

    /*

     * 使用文件保存多个学生信息,在程序中提供查询,添加,删除的功能

     * 分析:

          1.info.txt文件保存学生信息

          2.main方法中使用while循环不断的接收用户的操作

          3.查询,添加,删除分别封装成方法

     */

    publicclassStudentDemo {

       static Scanner sc = new Scanner(System.in);

     

       publicstaticvoid main(String[] args) throws Exception {

     

          while (true) {

             System.out.println();

             System.out.println("请根据下面选项输入您想要的操作");

             System.out.println("1.查询 2.删除 3.添加 4.显示 5.退出");

             System.out.println("请输入您的选项: ");

             intitem = sc.nextInt();

     

             switch (item) {

             case 1:

                search();

                break;

             case 2:

                System.out.println("删除");

                delete();

                break;

             case 3:

                add();

                System.out.println("添加");

                break;

             case 4:

                System.out.println("显示");

                showAll();

                break;

             case 5:

                System.out.println("感谢您的使用");

                System.exit(-1);

                break;

             }

          }

     

       }

     

       // 添加元素

       privatestaticvoid add() throws Exception {

          System.out.println("输入要添加的学号:");

          Stringnum= sc.next();

          if (!isExists(num)) {

             System.out.println("输入姓名:");

             Stringname= sc.next();

             System.out.println("输入成绩:");

             Stringscore= sc.next();

     

             // 输出流

             BufferedWriterbw = new BufferedWriter(new FileWriter("info.txt",true));

             bw.write(num + "," + name + "," + score);

             bw.newLine();

             bw.flush();

             bw.close();

             System.out.println("添加成功");

          }else{

             System.out.println("你输入的学号已经存在.");

          }

     

       }

     

       // 删除

       privatestaticvoid delete() throws Exception, IOException,Exception {

          System.out.println("输入将要删除掉的学号: ");

          Stringnum= sc.next();

     

          if (isExists(num)) {

             BufferedReaderbr = new BufferedReader(new FileReader("info.txt"));

             ArrayList<String>list= newArrayList<>();

     

             Stringinfo= null;

             while ((info = br.readLine()) != null) {

                if (!info.startsWith(num)) {

                    list.add(info);

                }

             }

             br.close();

     

             // 将剩余的信息写回原文件

             BufferedWriterbw = new BufferedWriter(new FileWriter("info.txt"));

             for (String infos : list) {

                bw.write(infos);

                bw.newLine();

                bw.flush();

             }

             bw.close();

             System.out.println("删除成功");

          }else{

             System.out.println("你输入的学号不存在");

          }

       }

     

       // 显示所有信息

       privatestaticvoid showAll() throws Exception {

          BufferedReaderbr= newBufferedReader(newFileReader("info.txt"));

     

          System.out.println("学号\t姓名\t成绩");

          Stringline= null;

          while ((line = br.readLine()) != null) {

             String[]split= line.split(",");

             System.out.println(split[0] + "\t" + split[1] + "\t" + split[2]);

          }

       }

     

       // 查找功能

       privatestaticvoid search() throws Exception {

          System.out.println("请输入要查询的学号:");

          Stringnum= sc.next();

     

          // 判断学号是否存在

          if (isExists(num)) {

             BufferedReaderbr= newBufferedReader(newFileReader("info.txt"));

             Stringline= null;

             while ((line = br.readLine()) != null) {

                if (line.startsWith(num)) {

                    System.out.println("学号\t姓名\t成绩");

     

                    // 切割

                    String[]split= line.split(",");

                    System.out.println(split[0] + "\t" + split[1] + "\t" + split[2]);

                }

             }

          }else{

             System.out.println("您输入的学号不存在");

          }

       }

     

       // 判断学号是否存在

       privatestaticboolean isExists(String num) throws Exception {

          BufferedReaderbr= newBufferedReader(newFileReader("info.txt"));

          ArrayList<String>list= newArrayList<>();

     

          Stringline= null;

          while ((line = br.readLine()) != null) {

             list.add(line);

          }

     

          // 遍历集合

          for (String info : list) {

             if (info.startsWith(num)) {

                returntrue;

             }

          }

          returnfalse;

       }

     

    }

     

    展开全文
  • 21学通java( 第一版)书上源码和习题答案.rar
  • 比较能够容易理解java的异常类的文档,适用于初学者学习,可以初步对异常类有一个比较笼统的认识
  • 本书深入浅出,讲的非常适合初学Java的爱好者。也可供学习其他语言的程序员学习Java是参考
  • 反射机制练习题 前面我们对反射机制的理论知识进行了学习,现在我们来实际应用,从而更加了解它。首先我们先创建Person类,和Teacher类继承Person类(包含注解),供我们反射使用,具体如下: package ...

    反射机制练习题

    前面我们对反射机制的理论知识进行了学习,现在我们来实际应用,从而更加了解它。首先我们先创建Person类,和Teacher类继承Person类(包含注解),供我们反射使用,具体如下:

    package com.atguigu.javase.reflect;
    
    import java.io.Serializable;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    
    import org.junit.Test;
    
    @Retention(RetentionPolicy.RUNTIME) // 保持在运行时,才可以通过反射获取
    @interface MyAnn {
    	String name() default "张三";
    	int age() default 30;
    }
    
    // 创建Person类,为完成反射提供一个简单的类
    class Person {
    	
    	public String gender;
    	public int height;
    	public double weight;
    	
    	private void privateTest() {
    		System.out.println("Person.privateTest()");
    	}
    }
    
    // 创建Teacher类继承Person类
    @MyAnn
    public class Teacher extends Person implements Serializable, Comparable {
    	
    	private static int counter = 100;
    	
    	public static void test() {
    		System.out.println("static test()");
    	}
    	
    	public String name;
    	private int age;
    	private double salary;
    	
    	public Teacher() {
    	}
    	
    	private Teacher(String name, int age, double salary) {
    		super();
    		this.name = name;
    		this.age = age;
    		this.salary = salary;
    	}
    
    	public void eat(String something) {
    		System.out.println("老师在吃" + something);
    	}
    	
    	public void eat(String something, int time) {
    		System.out.println("老师在吃" + something + "吃了" + time + "小时");
    	}
    	
    	@MyAnn(name="李四", age=40)
    	private static final String concat(int i, double d, char c, boolean b) {
    		return "" + i + d + c + b;
    	}
    
    	@Override
    	public String toString() {
    		return "Teacher [name=" + name + ", age=" + age + ", salary=" + salary + "]";
    	}
    
    	@Override
    	public int compareTo(Object o) {
    		return 0;
    	}
    	
    }
    
    现在我们就可以测试反射创建对象、调用属性、方法等和正常情况创建有什么区别?

    package com.atguigu.javase.reflect;
    
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.InputStreamReader;
    import java.io.PrintStream;
    import java.lang.annotation.Annotation;
    import java.lang.reflect.Constructor;
    import java.lang.reflect.Field;
    import java.lang.reflect.InvocationTargetException;
    import java.lang.reflect.Method;
    import java.lang.reflect.Modifier;
    import java.lang.reflect.ParameterizedType;
    import java.lang.reflect.Type;
    import java.util.HashSet;
    import java.util.Iterator;
    import java.util.Properties;
    import java.util.Set;
    
    import org.junit.Test;
    
    
    public class ReflectTest {		
    	// 正常方式创建对象,调用方法
    	@Test
    	public void test1() {
    		/*
    		Teacher t1 = new Teacher(); // 由JVM自动 加载类, 再创建对象.
    		t1.name = "小明";
    		t1.age = 20;
    		t1.salary = 1000;
    		System.out.println(t1.name);
    		System.out.println(t1.age);
    		System.out.println(t1.salary);
    		t1.eat("回锅肉");
    		System.out.println(t1);
    		*/
    	}
    
    	// 通过反射获取类的属性,以及私有属性的获取
    	@Test
    	public void test2() {
    		try {
    			Class clazz = Class.forName("com.atguigu.javase.reflect.Teacher");// 根据类的全限定名称加载类并创建类模板对象,
    			//加载类的过程就是由类加载器读取Teacher.class二进制文件,由类加载器生成Class对象
    			// 类模板对象中包含了类中的属性的定义(Field对象)和方法的代码(Method对象)
    			Object object = clazz.newInstance(); // 对象的创建由方法来完成, 调用类的无参构造器创建对象
    			System.out.println(object);
    			
    			//((Teacher)object).name = "小红";
    			//Field ageField = clazz.getField("age"); // 只能获取公共的属性
    			Field ageField = clazz.getDeclaredField("age"); // 只在在本类中声明了的属性, 就可以获取到!!!, 不受访问控制修饰
    			ageField.setAccessible(true);
    			ageField.set(object, 40);// 相当于object.age = 40;
    			System.out.println(ageField.get(object)); // System.out.println(object.age);
    			
    			Field salaryField = clazz.getDeclaredField("salary");
    			System.out.println(salaryField);
    			salaryField.setAccessible(true); // 突破封装,实现私有成员的访问
    			salaryField.set(object, 5000);
    			System.out.println(salaryField.get(object));
    			
    			Field nameField = clazz.getDeclaredField("name");
    			nameField.setAccessible(true); // 突破封装,实现私有成员的访问
    			nameField.set(object, "小红");
    			
    			System.out.println(object);
    			
    		} catch (ClassNotFoundException e) { // 类名不正确, 根据类名找到.class文件
    			e.printStackTrace();
    		} catch (InstantiationException e) { // 构造器调用错误!!
    			e.printStackTrace();
    		} catch (IllegalAccessException e) { // 构造器封装
    			e.printStackTrace();
    		} catch (NoSuchFieldException e) {
    			e.printStackTrace();
    		} catch (SecurityException e) {
    			e.printStackTrace();
    		} 
    	}
    
     	// 通过反射获取类实现了哪些接口
    	@Test
    	public void test3() {
    		try {
    			Class clazz = Class.forName("com.atguigu.javase.reflect.Teacher");
    			Class superClazz = clazz.getSuperclass();
    			System.out.println(superClazz);
    			Class[] interfaceArr = clazz.getInterfaces();
    			for (int i = 0; i < interfaceArr.length; i++) {
    				System.out.println("实现接口:" + interfaceArr[i]);
    			}
    		} catch (ClassNotFoundException e) {
    			e.printStackTrace();
    		}
    	}
    
    	//  创建对象的4种方法
    	@Test
    	public void test4() {
    		try {
    			//1) 常规使用, 软编码
    			Class clazz1 = Class.forName("com.atguigu.javase.reflect.Teacher");
    			
    			//2) 最简单, 硬编码
    			Class clazz2 = Teacher.class;
    			
    			System.out.println(clazz1 == clazz2);
    			
    			//3) 比较灵活, 硬编码
    			Class clazz3 = new Teacher().getClass();
    			System.out.println(clazz2 == clazz3);
    			
    			//4) 比较复杂, 先获取到类加载器对象,再手工加载类, 软编码
    			ClassLoader classLoader = this.getClass().getClassLoader();
    			Class clazz4 = classLoader.loadClass("com.atguigu.javase.reflect.Teacher");
    			System.out.println(clazz3 == clazz4);
    			
    		} catch (ClassNotFoundException e) {
    			e.printStackTrace();
    		}
    	}
    	
    	// 通过反射获取类加载器
    	@Test
    	public void test5() {
    		ClassLoader appClassLoader = ClassLoader.getSystemClassLoader();
    		System.out.println(appClassLoader);
    		
    		ClassLoader extClassLoader = appClassLoader.getParent();
    		System.out.println(extClassLoader);
    		
    		ClassLoader bootstapClassLoader = extClassLoader.getParent();
    		System.out.println(bootstapClassLoader);
    		
    		System.out.println("" + Object.class.getClassLoader());// 引导类加载器加载核心类
    		System.out.println("" + Person.class.getClassLoader());
    	}
    
    	@Test
    	public void test6() throws IOException {
    		// 通类加载器读取的资源文件的当前目录不是项目目录, 而是src目录
    		// src目录就是项目的classpath中的
    		// 可以直接从jar包中读取资源文件
    		//InputStream is = this.getClass().getClassLoader().getResourceAsStream("resource.properties");
    		InputStream is = this.getClass().getClassLoader().getResourceAsStream("com/sun/corba/se/impl/logging/LogStrings.properties");
    		Properties properties = new Properties();
    		properties.load(is);
    		System.out.println(properties.getProperty("IOR.nullPoa"));
    	}
    
    	// 通过反射获取类的方法,并实现方法
    	@Test
    	public void test7() {
    		try {
    			Class clazz = Class.forName("com.atguigu.javase.reflect.Teacher");
    			Object object = clazz.newInstance();
    			
    			Field nameField = clazz.getDeclaredField("name");
    			nameField.setAccessible(true);
    			nameField.set(object, "小明");
    			
    			System.out.println(object);
    			
    			// 调用方法
    			// 1) 从类模板对象中获取方法对象, getMethod会获取本类或者从父类继承的所有公共方式
    			Method eatMethod1 = clazz.getMethod("eat", String.class);
    			// 2) 通过方法对象间接调用自己
    			Object retValue = eatMethod1.invoke(object, "肉包子"); // object.eat("肉包子");
    			System.out.println("方法返回值:" + retValue);
    			
    			Method eatMethod2 = clazz.getMethod("eat", String.class, int.class);
    			eatMethod2.invoke(object, "紫菜包饭", 5);
    			
    			Method toStringMethod = clazz.getMethod("toString");
    			Object retValue2 = toStringMethod.invoke(object);
    			System.out.println(retValue2);
    			
    			Method hashCodeMethod = clazz.getMethod("hashCode");
    			Object retValue3 = hashCodeMethod.invoke(object);
    			System.out.println(retValue3);
    			
    			// 可以获取本类所有方法,包括私有方法
    			Method concatMethod = clazz.getDeclaredMethod("concat", int.class, double.class, char.class, boolean.class);
    			concatMethod.setAccessible(true);
    			Object retValue4 = concatMethod.invoke(object, 100, 3.14, '你', true);
    			System.out.println(retValue4);
    			
    			System.out.println("修饰符:" + Modifier.toString(concatMethod.getModifiers()));
    			Annotation annotation = concatMethod.getAnnotation(Test.class); // 获取注解
    			System.out.println(annotation);
    			
    			// getDeclaredMethod, 只能获取本类中声明的方法,从父类继承的无法拿到
    			//Method getClassMethod = clazz.getDeclaredMethod("getClass");
    			//System.out.println(getClassMethod);
    			
    			// 获取父类的私有方法,并通过子类对象来调用, 也是可以成功的, 说明子类继承父类的所有成员!!
    			Method method = clazz.getSuperclass().getDeclaredMethod("privateTest");
    			method.setAccessible(true);
    			method.invoke(object);
    			
    		} catch (ClassNotFoundException e) {
    			e.printStackTrace();
    		} catch (InstantiationException e) {
    			e.printStackTrace();
    		} catch (IllegalAccessException e) {
    			e.printStackTrace();
    		} catch (NoSuchFieldException e) {
    			e.printStackTrace();
    		} catch (SecurityException e) {
    			e.printStackTrace();
    		} catch (NoSuchMethodException e) {
    			e.printStackTrace();
    		} catch (IllegalArgumentException e) {
    			e.printStackTrace();
    		} catch (InvocationTargetException e) {
    			e.printStackTrace();
    		}
    	}
    
    	// 通过反射获取构造器对象,从而完成对象的创建
    	@Test
    	public void test8() {
    		try {
    			Class clazz = Class.forName("com.atguigu.javase.reflect.Teacher");
    			// 使用其他构造器创建对象
    			// 1) 先获取到构造器对象
    			//Constructor constructor = clazz.getConstructor(String.class, int.class, double.class);
    			Constructor constructor = clazz.getDeclaredConstructor(String.class, int.class, double.class);
    			int modifiers = constructor.getModifiers(); // 获取修饰符
    			Class[] typesClasses = constructor.getParameterTypes();
    			for (int i = 0; i < typesClasses.length; i++) {
    				System.out.println("构造器参数:" + typesClasses[i]);
    			}
    			System.out.println(Modifier.toString(modifiers));
    			
    			constructor.setAccessible(true);
    			// 2) 间接调用构造器完成对象创建
    			Object object = constructor.newInstance("立超", 19, 10000);
    			System.out.println(object);
    			
    			Constructor runtimeConstructor = Runtime.class.getDeclaredConstructor();
    			System.out.println(runtimeConstructor);
    			runtimeConstructor.setAccessible(true);
    			Object object2 = runtimeConstructor.newInstance();
    			System.out.println(object2);
    			System.out.println(Runtime.getRuntime());
    			
    			System.out.println(Object.class.getSuperclass());
    			
    		} catch (ClassNotFoundException e) {
    			e.printStackTrace();
    		} catch (NoSuchMethodException e) {
    			e.printStackTrace();
    		} catch (SecurityException e) {
    			e.printStackTrace();
    		} catch (InstantiationException e) {
    			e.printStackTrace();
    		} catch (IllegalAccessException e) {
    			e.printStackTrace();
    		} catch (IllegalArgumentException e) {
    			e.printStackTrace();
    		} catch (InvocationTargetException e) {
    			e.printStackTrace();
    		}
    	}
    
    	// 通过反射获取私有方法,注解
    	@Test
    	public void test9() {
    		try {
    			Class clazz = Class.forName("com.atguigu.javase.reflect.Teacher");
    			Annotation classannotation = clazz.getAnnotation(MyAnn.class);
    			System.out.println(classannotation);
    			
    			// 可以获取本类所有方法,包括私有方法
    			Method concatMethod = clazz.getDeclaredMethod("concat", int.class, double.class, char.class, boolean.class);
    			System.out.println("修饰符:" + Modifier.toString(concatMethod.getModifiers()));
    			Annotation annotation = concatMethod.getAnnotation(MyAnn.class); // 获取注解
    			System.out.println(annotation);
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    	}
    
    	// 通过反射获取一个类的构造器,属性,方法
    	@Test
    	public void test10() throws Exception {
    		String className = "java.util.HashMap";
    		Class clazz = Class.forName(className);
    		Constructor[] allConstructors = clazz.getDeclaredConstructors(); // 本类中声明的所有构造器
    		for (int i = 0; i < allConstructors.length; i++) {
    			System.out.println(allConstructors[i]);
    		}
    		System.out.println("----------------------");
    		Field[] allFields = clazz.getDeclaredFields(); // 本类中声明的所有的属性
    		for (int i = 0; i < allFields.length; i++) {
    			System.out.println(allFields[i]);
    		}
    		Field[] allPublicFields = clazz.getFields(); // 获取本类及从父类继承的所有公共属性
    		for (int i = 0; i < allPublicFields.length; i++) {
    			System.out.println(allPublicFields[i]);
    		}
    		System.out.println("-----------------------------");
    		Method[] allMethods = clazz.getDeclaredMethods(); // 本类声明的所有方法
    		for (int i = 0; i < allMethods.length; i++) {
    			System.out.println(allMethods[i]);
    		}
    		Method[] allPublicMethods = clazz.getMethods(); // 获取本类及从父类继承的所有公共方法
    		for (int i = 0; i < allPublicMethods.length; i++) {
    			System.out.println(allPublicMethods[i]);
    		}
    	}
    	
    	// 写一个方法printClassDetails(String className)
    	// 先打印类名和父类(getSuperClass())及实现的接口(getInterfaces())
    	// 在方法中打印类模板中的所有构造器,所有属性(包含从父类继承的公共属性), 所有方法(包含从父类继承的公共方法) 要求不要重复打印
    	// 打印的时候注意一下缩进
    	public void printClassDetails(String className) throws ClassNotFoundException {
    		Class clazz = Class.forName(className);
    		System.out.print("public class " + clazz.getSimpleName() + " extends " + clazz.getSuperclass().getSimpleName());
    		System.out.print(" implements ");
    		Class[] allInterface = clazz.getInterfaces();
    		for (int i = 0; i < allInterface.length; i++) {
    			System.out.print(allInterface[i].getSimpleName() + ",");
    		}
    		System.out.println("{");
    		System.out.println();
    		Set<Field> allFields = new HashSet<Field>();
    		for (Field field : clazz.getFields()) {
    			allFields.add(field);
    		}
    		for (Field field : clazz.getDeclaredFields()) {
    			allFields.add(field);
    		}
    		
    		Iterator<Field> iterator = allFields.iterator();
    		while (iterator.hasNext()) {
    			System.out.println("\t" + iterator.next());
    		}
    		
    		System.out.println();
    		
    		for (Constructor constructor : clazz.getDeclaredConstructors()) {
    			System.out.println("\t" + constructor);
    		}
    		System.out.println();
    		Set<Method> allMethods = new HashSet<Method>();
    		for (Method method : clazz.getMethods()) {
    			allMethods.add(method);
    		}
    		for (Method method : clazz.getDeclaredMethods()) {
    			allMethods.add(method);
    		}
    		System.out.println();
    		for (Method method : allMethods) {
    			System.out.println("\t" + method);
    		}
    		System.out.println("}");
    	}
    	
    	// 调用printClassDetails方法
    	@Test
    	public void exer1() {
    		try {
    			printClassDetails("java.io.ObjectOutputStream");
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    	}
    	
    	// 静态属性、静态方法的访问
    	@Test
    	public void test11() {
    		try {
    			Class clazz = Class.forName("com.atguigu.javase.reflect.Teacher");
    			//Object object = clazz.newInstance();
    			Field counterField = clazz.getDeclaredField("counter");
    			System.out.println(counterField);
    			counterField.setAccessible(true);
    			System.out.println(counterField.get(null)); // 静态属性的访问不需要对象, 所以传入null也可以
    			counterField.set(null, 10000); // 静态的设置也不需要对象
    			System.out.println(counterField.get(null)); // 静态属性的访问不需要对象, 所以传入null也可以
    			
    			Method testMethod = clazz.getMethod("test");
    			testMethod.invoke(null);
    			
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    	}	
    	
    	<span style="color:#ff0000;">// 反射在自定义泛型中的应用
    	// 通过反射获取子类的泛型类型->创建父类对象</span>
    	@Test
    	public void test12() throws InstantiationException, IllegalAccessException {
    		Parent parent1 = new Child1();
    		Parent parent2 = new Child2();
    	}	
    }
    
    
    // 上面test12测试所需要的类,其中父类为自定义泛型类,子类确定泛型的类型,在父类无参构造器中通过反射获取到子类的泛型// 类型从而确定父类的泛型类型,然后创建对象,从而实现对象的创建
    class Parent<T> {
    	
    	T t;
    	Class clazz;
    	
    	public Parent() {
    		Type type = this.getClass().getGenericSuperclass();
    		if (!(type instanceof ParameterizedType)) { // 在子类的声明中并没有任何的泛型信息
    			clazz = Object.class;
    		} else {
    			ParameterizedType parameteredType = (ParameterizedType)type;
    			Type[] types = parameteredType.getActualTypeArguments();
    			clazz = (Class)types[0];
    		}
    		System.out.println(clazz);
    		try {
    			t = (T) clazz.newInstance();
    			System.out.println(t);
    		} catch (InstantiationException | IllegalAccessException e) {
    			e.printStackTrace();
    		}
    	}
    	
    	public T getT() {
    		return t;
    	}
    }
    
    class Child1 extends Parent<Person> {
    }
    class Child2 extends Parent {
    }
    class Child3 extends Parent<PrintStream> {
    }
    // 反射可以应用在泛型类中,但是更加凸显出去其作用是在动态中
    展开全文
  • 本节书摘来异步社区《21天学通Java(第7版)》一书中的第1章,第1.10节,作者: 【美】Rogers Cadenhead(罗格斯 卡登海德),更多章节内容可以访问云栖社区“异步社区”公众号查看。 1.10 练习 为巩固本章介绍的...
  • 如何使用现有类本文节选自《21天学通JAVA》一书 在定义一些类的时候,如何使用它们呢?这里需要分为多种情况。定义的类可以在一个包下面,也可以不在一个包下面,这在使用时是不同的。类又分为已有类和自定义类,...
  • 武汉大学出版社 《Java程序设计教程》习题及参考答案
  • Java习题(06)UML基础

    2020-04-11 14:32:26
    书上第六章课后习题7(P169页),具体内容见学习通通知“第六章习题7” 要求实现根据UML图实现各个类及类间关系。 在各个方法中添加适当的输出函数显示调用了该方法。 在主测试类中新建实例并调用各方法以显示相关内容...
  • JAVA萌新学习day11 练习题 做个小练习题把 /* 创建 Song SongList SongListManager类 Song类 成员变量 1. 歌曲名 字符串类型 2. 歌曲类型 字符串类型 3. 歌手名 字符串类型 4. 歌曲播放时长 SongList类 成员变量 1....
  • 初次学习这部分会感觉很难,主要是概念难于理解,最好是多看看例子,多练习。下面是个人的总结 一、集合框架及泛型1、集合框架是一套性能优良、使用方便的接口和类(位于java.util包中)解决数组在存储上不能很好...
  • 一、单选(30分) 1.Java语言是( )。 A.面向问题的解释型高级编程语言 B.面向机器的低级编程语言 C.面向过程的编译型高级编程语言 D.面向对象的解释型高级编程语言 2.下列的变量定义中,错误的是( )。 A) int i...
  • web学习通作业4

    2020-04-30 16:28:55
    答案仅供参考 1 【单选】 JSP页面上有语句<%String str=“你好”;....java B、 .jsp C、 .html D、 .class 我的答案:A 3 【单选】 以下说法正确的是? A、 JSP动作标记为JSP页面提供全局变量 ...
  • import java.io.FileReader; import java.io.IOException; import org.junit.Test; public class IOTest { @Test public void testReader() { // 1) 声明流对象引用,并赋值为null; Fi
  • Java新手如何学习Spring、Strurs、Hibernate三大框架? 1. 学习方法 1.1 给我一个可以运行的学习Demo 曾经有过面向百度学习框架的同学,一定会有这种感受,哗啦一搜,各种框架文章呀,真好,真好,趁着学习干劲足足的...
1 2 3 4 5 ... 20
收藏数 3,138
精华内容 1,255