精华内容
下载资源
问答
  • //11.1 package zuoye; import java.util.Scanner; public class one{ public static void main(String agrs[]){ Scanner in=new Scanner (System.in); //输入 System.out.print("En...
    //11.1
    package zuoye;
    import java.util.Scanner;
    public class one{   
        public static void main(String agrs[]){ 
            Scanner in=new Scanner (System.in);
            //输入
            System.out.print("Enter a,b,c:");
            int a=in.nextInt();
            int b=in.nextInt();
            int c=in.nextInt();
            System.out.print("Enter color:");
            String color=in.next();
            System.out.println("1.true     2.false");
            System.out.print("Enter filled:");		
            int num = in.nextInt();
            boolean filled=true;
            if(num == 1)		
                filled = true;	
            else			
                filled = false;	
            //boolean filled=in.;
            //test1.setColor("");
            //test1.setFilled(false);
            SimpleGeometricObject test1=new SimpleGeometricObject( color,  filled); 
            Triangle test = new Triangle(a,b,c); 
            //输出
            System.out.println(test.toString());  
            System.out.println(test1.toString());  
        }
    }   
    class SimpleGeometricObject{  
        private String color = "white"; 
        private boolean filled;   
        private java.util.Date dateCreated;   
        public SimpleGeometricObject(){ 
            dateCreated = new java.util.Date();   
        }     
        public SimpleGeometricObject(String color, boolean filled){     
            dateCreated = new java.util.Date();  
            this.color = color;    
            this.filled = filled;  
        }   
        public String getColor(){   
            return color; 
        }    
        public void setColor(String color){   
            //System.out.print("Enter color:");	
            //Scanner cin = new Scanner(System.in);	
            //String num = cin.next();	
            //this.color = num;
            this.color = color;  
        }    
        public boolean isFilled(){   
            return filled;
        }    
        public void setFilled(boolean filled){  
            //System.out.print("Enter filled:");	
            //Scanner cin = new Scanner(System.in);	
            //boolean num = cin.hasNextBoolean();	
            //this.filled = num;
            this.filled = filled;   
        }     
        public java.util.Date getDateCreated(){     
            return dateCreated; 
        }    
        public String toString(){  
            return "created on " + dateCreated + "\ncolor: "
                    + color + " and  filled: " + filled; 
        }
    } 
    class Triangle extends SimpleGeometricObject{   
        private double side1 = 1.0;  
        private double side2 = 1.0;  
        private double side3 = 1.0;  
        public Triangle(){ 
            super();    
            side1 = side2 = side3 = 1.0;   
        }  
        public Triangle(double side1, double side2, double side3){   
            super();      
            this.side1 = side1;     
            this.side2 = side2;  
            this.side3 = side3;   
        }    
        public double getSide1(){    
            return side1;  
        }   
        public double getSide2(){ 
            return side2;
        }   
        public double getSide3(){    
            return side3;   
        }    
        public double getArea(){    
            double p = (side1 + side2+ side3) / 2; 
            return Math.sqrt(p * (p-side1) * (p-side2) * (p-side3)); 
        }    
        public double getPerimeter(){   
            return side1 + side2 + side3; 
        }   
        public String toString(){   
            return "Triangle:  side1=" +side1+"  side2="+side2+"  side3="+side3+"\nArea: "
                    + this.getArea() + "\nPerimeter: " + this.getPerimeter(); 
        }
    }
    
    
    //11.4
    package zuoye;
    import java.util.ArrayList;
    import java.util.Scanner;
    public class four {  
        public static void main(String[] args) {  
            ArrayList<Integer> list = new ArrayList<>();  
            Scanner sc = new Scanner(System.in);   
            System.out.print("Enter integers (input ends with 0): "); 
            int value;     
            do{         
                value = sc.nextInt();   
                if(!list.contains(value)&&value!=0){    
                    list.add(value);      
                }    
            }while(value!=0);    
            System.out.println("The max Integer is : "+max(list));
        }         
        public static Integer max(ArrayList<Integer> list){   
            if(list.size()==0){    
                return null;    
            }       
            int i=list.get(0);       
            for (Integer integer : list) {   
                i=i>integer?i:integer;   
            }     
            return i;  
        } 
    }
    
    
    //11.6
    package zuoye;
    import java.util.Scanner;
    import java.util.ArrayList;
    import java.util.Date;
    public class five {   
        public static void main(String[] args) {    
            ArrayList<Object> obj = new ArrayList<>(); 
            obj.add(new Date());   
            obj.add("this is a string");   
            for(Object tmp : obj){    
                System.out.println(tmp.toString());   
            } 
        } 
    }
    
    
    //11.7
    package zuoye;
    import java.util.ArrayList;
    import java.util.Random;
    import java.util.Scanner;
    public class six {
        public static void main(String[] args) { 
            ArrayList<Integer> list = new ArrayList<>();
            Scanner input = new Scanner(System.in); 
            System.out.print("Enter integers (input ends with 0): ");
            while(true){       
                int num = input.nextInt();   
                if(num == 0) break; 
                else list.add(num); 
            }
            System.out.print(" Integers is: ");
            shuffle(list);  
            list.forEach((jkl) -> {  
                System.out.print(jkl + " ");
            }); 
        }
        public static void shuffle(ArrayList<Integer> list) {    
            Integer xiabiao;
            int temp;     
            Random rand = new Random();  
            for(int i = 0;i<list.size();i++) {   
                xiabiao = rand.nextInt(list.size());      
                temp = list.get(i);          
                list.set(i, list.get(xiabiao));     
                list.set(xiabiao, temp);  
            }
        }   
    }
    
    
    //11.9
    package zuoye;
    import java.util.ArrayList;
    import java.util.Objects;
    import java.util.Random;
    import java.util.Scanner;
    public class two { 
        public static void main(String[] args) { 
            ArrayList<Integer> list1 = new ArrayList<>();
            ArrayList<Integer> list2 = new ArrayList<>();  
            Scanner input = new Scanner(System.in);  
            System.out.print("Enter the array size n: "); 
            int num = input.nextInt();  
            System.out.println("The random array is"); 
            Integer row = 0;      
            Integer column = 0;  
            Integer row_Max = 0;  //行里面最多有几个1   
            Integer column_Max = 0; //列里面最多有几个1  
            int[][] array = new int[num][num];  
            Random rand = new Random();    //完成初始化并且用Max记录行、列里面各自最多有几个1   
            for (int[] array1 : array) {
                for (int j = 0; j < array[0].length; j++) {
                    int randInt = rand.nextInt(2);
                    array1[j] = randInt;
                    System.out.print(array1[j] + " ");
                    if(randInt == 1) row++; //‘1’ 的行累加器   
                }
                if(row > row_Max) 
                    row_Max = row;  //存储行里面最多有几个1        
    //归零    
                row = 0;
                System.out.println();
            }   
            for(int i = 0;i < array.length;i++) { 
                for(int j = 0;j < array[0].length;j++) {      
                    if(array[j][i] == 1) column++;
                }
             //‘1’的列累加器    
            if(column > column_Max) 
                column_Max = column;          
            column = 0; 
            }  
            for(int i= 0;i < array.length;i++) {     
                for(int j = 0;j < array[0].length;j++) {           
                    if(array[i][j] == 1) row++;                 
            if(array[j][i] == 1) column++;   
                }   
                if(     Objects.equals(row, row_Max))          
                    list1.add(i);      
                if(     Objects.equals(column, column_Max))            
                    list2.add(i);        
                row = 0;               
                column = 0;        
            }       
            System.out.print("The largest row index: ");    
            list1.forEach(( a) -> {
                System.out.print(a + " ");      
            }); 
            System.out.print('\n'+"The largest coulmn index: ");  
            list2.forEach((b) -> {
                System.out.print(b + " ");  
            });
        }
    }
    
    
    
    //11.10
    package zuoye;
    import java.util.Scanner;
    import java.util.ArrayList;
    public class seven {   
        public static void main(String[] args) {   
            MyStack stack = new MyStack(); 
            Scanner in = new Scanner(System.in);
            System.out.print("Enter integers : "); 
            int value;
            for(int i=0;i<5;i++){
                value =in.nextInt();
                stack.add(value);
            }
            System.out.println(stack.toString() + "\n" + "倒序为: "+
                    stack.pop() + " " + stack.pop()+ " "+stack.pop()+ " "+stack.pop()+" "+  stack.pop());
        }
    }
        class MyStack extends ArrayList{  
            @Override   
            public boolean isEmpty(){   
                return super.isEmpty(); 
            }   
            public int getSize(){   
                return super.size();  
            }    
            public Object peek(){     
                return super.get(super.size()-1); 
            }    
            public Object pop(){   
                Object o = super.get(super.size()-1);    
                super.remove(super.size()-1);    
                return o;  
            }    
            public void push(Object o){   
                super.add(o);  
            }   
            @Override   
            public String toString(){    
                return "stack: " + super.toString(); 
            }
        }
    
    
    //11.13
    package zuoye;
    import java.util.Scanner;
    import java.util.ArrayList;
    public class three { 
        public static void main(String[] args) {
            ArrayList<Integer> list = new ArrayList<>(); 
            Scanner in =new Scanner(System.in);
            System.out.print("Enter 10 integers:"); 
            int value;
            //输入10个值
            for(int i=0;i<10;i++){
                value =in.nextInt();
                list.add(value);
            }
            //输出
            System.out.print("The distinct integrs are "); 
            removeDuplicate(list); 
            list.forEach((as) -> {   
                System.out.print(as+" ");
            });
            System.out.println(); 
        } 
        //删除重复元素
        public static void removeDuplicate(ArrayList<Integer> list) {    
            int size = list.size();    
            int remove = 0;    
            for(int i = 0; i < size -remove;i++) {     
                for(int j = 1+i; j < size - remove;j++) {          
                    if(list.get(i) == list.get(j)) {             
                        list.remove(j);                  
                        remove++;                       
                        j=j-1;               
                    }    
                } 
            }
        }
    }
    
    
    

     

    展开全文
  • //12.5 import java.util.Scanner; public class two{ public static void main(String[] args){ try{ Scanner in=new Scanner (System.in); System.out.print("Enter a,b,c:"...
    //12.5
    import java.util.Scanner;
    public class two{
        public static void main(String[] args){
            try{
                Scanner in=new Scanner (System.in);
                System.out.print("Enter a,b,c:");
                int a=in.nextInt();
                int b=in.nextInt();
                int c=in.nextInt();
                Triangle tri = new Triangle(a,b,c);
                System.out.println(tri.toString());
            }
            catch(IllegalTriangleException ex){
                System.out.println(ex);
            }
        }
    }
    class IllegalTriangleException extends Exception{
        private String message;
        public IllegalTriangleException(){
            message = "this is illegal";
        }
        public IllegalTriangleException(String argu){
            message = argu;
        }
        @Override
        public String toString(){
            return message;
        }
    }
    class Triangle extends SimpleGeometricObject{
        private double side1 = 1.0;
        private double side2 = 1.0;
        private double side3 = 1.0;
    
        public Triangle(){
            super();
            side1 = side2 = side3 = 1.0;
        }
        //在这里修改的
        public Triangle(double side1, double side2, double side3)
                throws IllegalTriangleException{
            super();
            this.side1 = side1;
            this.side2 = side2;
            this.side3 = side3;
            if(side1 + side2 <= side3 || side2 + side3 <= side1 || side1 + side3 <= side2)
                throw new IllegalTriangleException("You are wrong!!");
        }
        public double getSide1(){
            return side1;
        }
        public double getSide2(){
            return side2;
        }
        public double getSide3(){
            return side3;
        }
        public double getArea(){
            double p = (side1 + side2+ side3) / 2;
            return Math.sqrt(p * (p-side1) * (p-side2) * (p-side3));
        }
        public double getPerimeter(){
            return side1 + side2 + side3;
        }
        @Override
        public String toString(){
            return "created on " + super.getDateCreated() + "\ncolor: " + super.getColor() + "\nfilled: " + super.isFilled()
                    + "\nArea: " + this.getArea() + "\nPerimeter: " + this.getPerimeter();
        }
    }
    、、此处新建java类,写入下边程序!!!!
    public class SimpleGeometricObject{  
        private String color = "white"; 
        private boolean filled;   
        private java.util.Date dateCreated;   
        public SimpleGeometricObject(){ 
            dateCreated = new java.util.Date();   
        }     
        public SimpleGeometricObject(String color, boolean filled){     
            dateCreated = new java.util.Date();  
            this.color = color;    
            this.filled = filled;  
        }   
        public String getColor(){   
            return color; 
        }    
        public void setColor(String color){   
            //System.out.print("Enter color:");	
            //Scanner cin = new Scanner(System.in);	
            //String num = cin.next();	
            //this.color = num;
            this.color = color;  
        }    
        public boolean isFilled(){   
            return filled;
        }    
        public void setFilled(boolean filled){  
            //System.out.print("Enter filled:");	
            //Scanner cin = new Scanner(System.in);	
            //boolean num = cin.hasNextBoolean();	
            //this.filled = num;
            this.filled = filled;   
        }     
        public java.util.Date getDateCreated(){     
            return dateCreated; 
        }    
        public String toString(){  
            return "created on " + dateCreated + "\ncolor: "
                    + color + " and  filled: " + filled; 
        }
    } 
    
    
    //12.2
    import java.util.InputMismatchException;
    import java.util.Scanner;
    public class one {
        public static void main(String[] args) {
            Scanner cin = new Scanner(System.in);
            int a,b;
            boolean continueCin = true;
            do{
                try{
                    System.out.println("Please input two number:");
                    a = cin.nextInt();
                    b = cin.nextInt();
                    System.out.println("a + b = " + (a+b));
                    continueCin = false;
                }
                catch(InputMismatchException ex){
                    System.out.println("Try again.");
                    cin.nextLine();
                }
            }while(continueCin);
        }
    }
    
    //12.6
    import java.util.Scanner;
    public class threea
    {
        public static void main(String [] args)
        {
            Scanner input = new Scanner(System.in);
            try
            {
                System.out.print("Enter a hex number: ");
                String hexString = input.next();
                int decNumber = hexToDex(hexString);
                System.out.println("The decimal value for hex number " 
                    + hexString + " is " + decNumber);
            }
            catch (NumberFormatException ex)
            {
                System.out.println(ex.toString() + " not a hex string.");
            }
        }
        public static int hexToDex(String hexString) throws NumberFormatException
        {
            int result = 0;
            for (int i = hexString.length() - 1; i >= 0; i--)
            {
                int judge = judge(hexString.charAt(i));
                if (judge == -1)
                {
                    throw new NumberFormatException(hexString);
                }
                else
                    result += judge * Math.pow(16, (hexString.length() - i - 1));
            }
    
            return result;
        }
    
        public static int judge(char ch)
        {
            if (ch >= '0' && ch <= '9')
            {
                return (ch - '0');
            }
            else if (ch >= 'A' && ch <= 'F')
            {
                return (ch - 'A' + 10);
            }
            else
                return -1;
        }
    }
    

     

    展开全文
  • java语言程序设计(梁勇

    千次阅读 2019-09-03 13:43:51
    第一章 计算机、程序和java概述 时钟速度越快,给点单位时间内处理的命令就越多。 汇编器:将汇编语言转换为机器语言 源程序(源代码):由高级语言编写的程序 又分编译器和解释器。 java是编译语言 操作系统...

    第一章 计算机、程序和java概述

    时钟速度越快,给点单位时间内处理的命令就越多。
    汇编器:将汇编语言转换为机器语言
    源程序(源代码):由高级语言编写的程序
    又分编译器和解释器。
    java是编译语言
    操作系统(os):是运行在计算机上最重要的程序,用来管理和控制计算机的活动。其作用为:1、控制和监视系统的活动;2、分配和调配系统资源;3、调度操作,其中包括多进程、多线程、多处理
    多进程:计算机可以执行不同的程序,多个程序共享cpu,如一边听歌,一边上网
    多线程:对单独一个程序可以进行不同任务,如一边打字一边保存
    多处理(并行处理):多个cpu处理不同子任务,最后整合完成任务。
    java的三个版本:java se 标准版:用来开发客户端的程序;java ee企业版:用来开发服务器端的程序;java me 微型版:开发移动设备的程序
    java是从类方法中的main开始执行的。
    java源程序保存为.java文件(且文件名和公共类名完全相同),编译文件保存为.class,class文件有Java虚拟机(JVM)执行。
    java字节码可以在不同的硬件平台和操作系统上由JVM进行执行。

    第二章 基本程序设计

    在源代码中,字符串不能跨行,在字符串较长时,要用+进行连接。

    java的控制台输入

    java并不支持控制台的直接输入,需要间接使用Scanner类来创建属于它的对象,以读取来自System.in的输入。
    Scanner input = new Scanner(System.in)
    double 变量名 = input.nextDouble()

    命名常量

    final datetype CONSTANTNAME = value;
    如 final double PI = 3.1415926

    命名习惯

    变量和方法:使用小写来命名,当用多个单词来描述时,除第一个单词外,其他单词首字母需要大写
    类名:首字母也要大写
    常量:单词中所有字母大写

    幂运算

    Math.pow(a,b)

    整数型直接量

    二进制:0B
    八进制:0
    十六进制:0X

    类型转换

    类型转化要求将目标类型名放在括号内,紧随其后的是需要变换的变量或值。
    如 (int)3.1

    第三章 选择

    在java中,if 是一个方法,所以在其后需要加().
    布尔变量的声明:boolean 变量名=表达式;
    true和false都是直接量,类似于10这种数字量,可以直接使用,也属于保留字。

    产生随机数

    可以使用Math.random()获取一个0-1之间的double数,不包括1.

    逻辑操作符

    ! && || ^ 用于产生复合布尔表达式。

    第四章 数学函数、字符和字符串

    常用数学函数

    三角函数方法、指数函数方法、服务函数方法
    字符型数据:char 用单引号
    字符型数据可以和整数数据直接进行强制转化。

    Character类

    提供了方法用于字符测试,如Character.isDigit(ch)

    字符串类型

    String类,用双引号。
    实例方法:由一个特定的实例来调用,如 message.length() ,其中message为一个字符串变量
    静态方法:非实例方法,不使用对象来调用,如Math.pow(a,b)
    从控制台读取字符串:采用Scanner的next()方法。
    使用nextline()方法读取一整行文本,以回车为结束标志的字符串。
    从控制台读取字符:先使用nextline()读取一整行,然后使用,charAt(0)来返回第一个字符。

    第五章 循环

    输入重定向:java SentinelValue < input.txt
    输出重定向:java ClassName > output.txt

    第六章 方法

    等同于函数,但需要先进行声明,如 public(修饰符) static(修饰符) int(返回值类型) sum(s1,s2)
    对void方法的调用必须是一个语句,通过;结束。
    按值传递:在调用带参数的方法,实参的值传递给形参,无论方法中形参的值怎么改变,都不会对实参造成影响。
    重载方法:执行同样功能但是具有不同参数类型的方法。
    方法抽象和逐步求精:在解决问题时,先将其分为各个小步,得到各个小步骤的方法抽象;然后对方法的抽象进行逐步求精。

    第七章 一维数组

    数组:单个的数组变量可以引用一个大的数据集合。
    声明数组变量:元素类型[] 数组引用变量名;如 double[] mylist; 只是声明一个数组类型的变量名。
    声明数组后,并不占据内存位置,只是创建一个对数组的引用的存储位置,除非对数组进行创建之后。
    创建数组:元素类型[] 数组引用变量 = new 元素类型[数组大小] 如 double[] mylist = new double [10]
    数组初始化语法:直接对数组进行赋值,如 double[] mylist = {0.1,2.0};
    foreach循环:不使用下标对整个数组进行顺序循环,如 for(double e:mylist){System.out.print(e);}
    数组的复制:1、逐个元素复制;2、使用System中的arraycopy方法,System.arraycopy(sorceArray,0,targetArray,0,sorceArrar.length)

    将数组传递给方法

    当一个数组传递给方法时,数组的引用传递给方法。在方法中改变数组时,方法外的数组也会随之改变,因为方法内外的变量都只是引用,这一引用指向相同的数组变量。
    当方法中的参数是基本数据类型时,是按值传递;当方法中的参数是数组类型时,是按引用传递(此时,在方法中,也是对数组元素进行的操作)。

    从方法中返回数组

    当从方法中返回数组时,返回的是数组的引用。

    可变长参数列表

    具有同样类型的可变长度的参数可以传递给方法,并作为数组对待。
    方法中的参数声明如:typeName… parameterName

    Arrays类

    包括一些常规的数组操作方法。

    命令行参数

    main方法和普通方法一样,可以被调用。

    第八章 多维数组

    表格或矩阵中的数据被表示为多维数组。
    二维数组被认为是由一维数组的数组构成。

    第九章 对象和类

    在java程序中,至少包含一个类(主类),使用这一类的称为客户,java在运行系统时会调用这个主类的main方法。
    一个文件中只能有一个公共类,且此公共类要与文件同名。但当编译时,文件中的每一个类都会生成一个.class文件。
    将两个类合成一个,即通过在类中添加main方法来测试这个类。
    构造方法在使用new创建对象时被调用。
    构造方法:1、构造方法没有返回值,连void都没有;2、构造方法和类名相同;3、构造方法作用是初始化对象。
    构造方法有两个:1、无参构造方法,不加参数时默认调用;2、有参构造方法,有参数输入时被调用。
    一个类可以不定义构造方法,此时,调用默认构造方法。

    通过引用变量来访问对象

    类也是一种引用变量,它的使用可以参照与数组。
    同样需要声明,创建。如 Circle mycircle 此时,只是声明了一个Circle类型的变量,但内存中没有它对应的地址。若想变量引用对象,还需要新建一个对象,然后进行引用。如 mycircle = new Circle();或者直接一步,Circle mycircle = new Circle().
    严格的将mycircle 并非是一个对象,它仅仅是一个对对象的引用变量。
    通常对对象的使用是,先创建一个变量,然后将对象引用赋予变量,然后直接使用这个变量。但有些时候并不使用变量,而是直接对对象进行操作(即匿名操作)。

    引用数据域和null值

    当一个引用类型的数据域没有引用任何对象,那么它会被自动赋予一个null值,null类似于true 和 false ,都是类型直接量(即属于保留字)。
    各种数据域的默认值:数值数据域:0;引用数据域:null;字符数据域:’\u0000’;boolean数据域:false。但方法中局部变量的数据域不会被赋初值。

    基本类型变量和引用类型变量的区别

    每个变量都代表一个存储值的内存位置。声明一个变量时,就是在告诉编译器这个变量可以存储什么类型的值。对于基本类型变量来说,对于内存所存储的值就是基本类型变量的值;对于引用类型变量来说,对于内存所储的值是一个引用,是对象的存储地址(即此引用指明了这个对象所存储在内存中的位置)。
    将一个变量的值赋予另一个变量时,对于基本类型变量来说,就是将一个变量的实际值赋予了另一个变量(即新开辟了一个内存空间,此内存空间和原始内存空间存储的值相同,但是有两个存储空间);对于引用类型变量来说,是将变量的引用赋予给了新的变量(即新开辟的内存空间,仍然是一个只存放了一个引用的空间,只是两个空间指向同一个对象)。
    当对象不被引用时,它就会被认为是垃圾,会被回收,收回所占有的内存空间,此时称为“垃圾回收”,是java的一种独特机制。
    如果当一个对象不被使用时,可以显式地将它的引用变量赋予null值,此时,这个对象所占有的内存就会被释放。

    静态变量、常量和方法

    静态变量(类变量)可以被类的所以对象共享。静态方法不能访问类中的实例成员。
    实例变量是绑定在对象上的,因此不能被不同对象所共享,如Circle中的radius。
    而若想被类中的所以对象共用,则可以使用静态变量,静态变量存储在一个公共内存中。
    java支持静态变量和静态方法,静态方法不需要实例化就可以使用。如Math.pow(a,b).
    只需在声明前加static即可,如static int numberOfCircle; 常量是被类中所有成员共享的,之前加上final。
    实例方法可以调用静态方法和静态数据域,而反之不可以,但可以使用实例化后的方法和数据域。

    可见性修饰符

    可见性修饰符用在类、方法和数据域之前加public,用于决定一个类以及其成员的可见性。
    加public时,可以被任何一个类进行访问,而不加public时,默认可以被同一个包内的类进行访问,这被称为包私有或包内访问。
    包可以用来组织类。为完成这一目标,需要在程序中首先出现,package packageName; 如果在定义类时没有声明包,则放在默认包内,java一般建议把类放入包内,而不是使用默认包。
    private限定方法和数据域只能在自身类中被访问。

    数据域封装

    使数据域设为私有数据域,有利于类的保护。

    向方法传递对象参数

    给方法传递一个对象,就是把对象的引用传递给方法。
    java只有一种传递方式:值传递。在对象参数传递给方法时,传递的是引用变量的值。

    数组对象

    数组既可以存储基本数据类型,也可以存储对象。如Circle circleArray = new Circle[10];
    对象的数组实际上是引用变量的数组。

    不可变对象和不可变类

    将数据域私有,并且去掉set方法,没有一个返回指向可变数据域的引用的访问器方法。

    this 引用

    关键字this引用对象自身,但它也可以在构造方法内部用于调用类中的其他构造方法。
    使用this引用隐藏数据域:

    第十章 面向对象思考

    类的抽象和封装

    类的抽象是指类的实现和使用是分开的,类的封装是指细节被封装并且对用户隐藏。

    把基本数据类型作为对象来处理

    把基本数据类型并入对象或包装成对象,java为基本数据类型提供了Double Integer Character Boolean Float Short Long类,

    第十一章 继承和多态

    父类和子类

    继承:使用继承,避免冗余,提取类的公有特性,使系统更加易于理解和维护。
    通过extends来继承,如:public class Circle extends GeometricObject
    父类的数据域是私有的,子类若想使用,必须通过父类的公共的set,get方法。

    super

    使用super可以调用父类的构造方法和方法。且必须出现在子类构造方法的第一行。
    构造方法链:子类沿着父类的构造方法进行构造,直到找寻到最后一个父类为止。
    如果要设计一个可以被继承的类,那最好为其设计一个无参构造方法,防止程序出错。

    方法重写

    子类和父类中的方法具有同样的签名和参数时,当子类需要修改定义在父类的方法时。
    当子类中方法进行重写后,需要调用父类方法时,需在被调用的父类方法前加super(除此之外,调用父类方法无需super)。
    注意:私有方法不能被继承,也不能被重写;静态方法被重写之后,父类的静态方法会被隐藏,调用时需 父类名.静态方法名.

    方法重写与重载

    方法重载意味着同样的名字使用不同的签名来定义多个方法,而重写是在子类中对一个新方法的实现。
    重写标准:为防止出现错误,在子类中重写的方法前加以 @Override 。

    Object类和toString方法

    java中的所有类都继承自java.lang.Object类,toString是Object类中的一个方法,所以所有类都可以使用。
    public String toString():调用一个对象的toString()方法会返回一个关于此对象的描述。然而,返回的信息用处很小,因此通常重写此函数,来返回一个关于对象的有效描述。

    多态

    多态意味着父类的变量可以指向子类对象。即使用父类对象的地方都可以使用子类对象。
    因:子类的实例都可以看成是父类实例的特殊化,所以:总可以将父类的参数传递给子类的实例。

    动态绑定

    方法可以在继承链中的各个类中实现,JVM决定运行时调用哪个方法。
    声明类型和实际类型:如 Object o = new GeometricObject()
    o的声明类型是Object,实际类型是GeometricObject.
    声明类型可以看作是引用类型变量所属的类型,而实际类型是对象的类型。动态绑定中o调用哪个方法要由实际类型来决定。
    对象会沿着继承链从对象中实际类型开始查找方法,直至找到方法的实现,就调用此类中的方法。

    对象转换和instanceof运算符

    对象的引用可以类型转换为另一个对象的引用。
    子类的实例引用转换为父类时,无需指明,属于隐式转换。
    而父类向子类转换时,需要显式地转换。如:Student b = (Student) o, 此时需要确保的是o 是Student 的一个实例,负责会编译出错。
    instanceof 的用法:来确定一个对象是不是属于某个类,if (myCircle instanceof Circle)
    为了通用程序设计,通常把变量定义为父类型,这样即可接受任何子类型的值。

    protected 类和方法

    protected类和方法可以被子类继承和使用。
    private 和 protected只能用于类内成员,而public可以用于类内成员和类,不加修饰的类是不能被包内的其他类所访问的。
    子类可以将父类的protected方法改写为public

    防止扩展和重写

    在类或方法之前添加final即可以防止类的扩展和方法的重写。

    第十二章 异常处理和文本I/O

    异常处理概述

    异常是由方法抛出的,方法的调用者可以处理并捕获异常。
    通过try-throw-catch。
    异常处理的最根本优势是将检测错误从处理错误中分离出来。
    异常是对象,它的源类是java.lang.Throwable

    File类

    File类包括了获得一个文件/目录的属性,以及对其进行改名和删除的方法。但不包含读写文件内容的方法。

    文件的输入和输出

    通过Scanner类和PrintWriter类来实现。

    第十三章 抽象类和接口

    父类中定义了相关子类中的共同行为,接口可以用于定义非相关类的共同行为。

    抽象类

    抽象类不可以用于创建对象,抽象类可以包含抽象方法,这些方法将在具体的子类中实现。
    抽象方法:在抽象头中使用abstract来表示。如:public abstract double getArea();
    抽象类不能创建对象,一个包含抽象方法的类必须声明为抽象类,抽象类的构造方法需用protected来声明,用于子类继承。
    抽象类所扩展的抽象子类中,必须把抽象子类中所用抽象的方法都实现。

    接口

    接口是一种与类相似的结构,只包含常量和抽象方法。
    修饰符 interface 接口名 如:modifier interface InterfaceName

    第十四章 Java FX基础

    第十五章 事件驱动编程和动画

    第十六章 Jave FX UI组件和多媒体

    第十七章 二进制I/O

    文件分为文本的和二进制的,文本文件指的是用文本编辑器编辑的,其他的为二进制文件(为程序读取而设计)。如Java源程序保存为文本文件,而Java类为二进制文件(通过Java虚拟机读取)。
    二进制文件不涉及编码和解码,因此效率更高。

    第十八章 递归

    展开全文
  • java语言程序设计 梁勇 第十版答案,真的不错!良心制作,每章都归类在一个文件夹里,方便学习和自学!
  • java程序设计第8版(基础篇) PPT ,包含内容:循环、方法、数组、面向对象、继承、多态、GUI等
  • java程序设计(梁勇.第十版)全部补充材料,需要的可以下载
  • 好棒的代码呀
  • 本书作者是Y.Daniel Liang 即梁勇,普度大学终身教授,阿姆斯特朗亚特兰大州立大学计算机科学系教授。 本科和硕士研究生阶段就读于复旦大学计算机专业(分别起始于1983年和1986年),博士就读于俄克拉荷马大学计算机...
  • 第八版 文字版PDF 高清 可复制源码 英文版
  • 答案
  • Java语言程序设计 基础篇 原书第10版 ,梁勇
  • Java语言程序设计(第10版)梁勇 书本示例代码,为方便学习推荐大家下载使用
  • Java 语言程序设计 第11版 英文版 梁勇 PDF版本 Introduction to Java Programming and Data Structures, Comprehensive Version (11th Edition 版本) By 作者: Y. Daniel Liang
  • java语言程序设计 10th by梁勇 编程练习题答案
  • 梁勇JAVA语言程序设计奖励章节31到44章节,均为PDF版,
  • java程序语言设计 梁勇 第十版(基础篇+进阶篇) 课后习题答案
  • Java程序设计梁勇第十版第八章编程练习题

    千次阅读 热门讨论 2019-06-10 10:24:43
    } } /** Return two dimensional arrays */ public static double[][] getMatrix() { // Create a Scanner java.util.Scanner input = new java.util.Scanner(System.in); // Prompt the user to ...

    (前八章如果您有需要,直接在评论注说,我发给你)本章所有题目代码都是本人自己写的,全部自己运行成功了,可以直接复制粘贴。 这些重要都附加了英文注释,方便解析使大家明白,如果您在此阅读过程中发现程序代码有任何问题(包括代码的命名,代码逻辑,代码风格更好的建议,希望大家严格指出来,哪段代码没注释没看懂或注释不清晰,诸如此类等等…)都可以向我提出来。以便大家学习交流

    Practice 8-1

    /**
    * 需求:打印用户输入的数组数据中的每列数字之和
    * 步骤:略(以后太简单的题目步骤都省略)
    * 作者:小小鱼
    * 时间:2019 - 6 - 99号
    */
    /** Create main method */
    	public static void main(String args []) {
    		// Read two dimensional arrays by getMatrix of method
    		double[][] matrix = getMatrix();
    		
    		for (int column = 0; column < matrix[0].length; column++) {
    			System.out.println("Sum of the elements at column " + column
    					 + " is " + sumColumn(matrix, column));
    		}
    	}
    	
    	/** Return two dimensional arrays */
    	public static double[][] getMatrix() {
    		// Create a Scanner
    		java.util.Scanner input = new java.util.Scanner(System.in);
    		
    		// Prompt the user to enter a 3-by-4 matrix row by row
    		System.out.println("Enter a 3-by-4 matrix row by row: ");
    		
    		// Create a arrays and row'length is 3, column'length is 4 of the matrix
    		double [][] matrix = new double[3][4];
    		
    		// Read and store data into arrays through user input
    		for (int row = 0; row < matrix.length; row++) {
    			for (int column = 0; column < matrix[row].length; column++) {
    				matrix[row][column] = input.nextDouble();
    			}
    		}
    		
    		return matrix;
    	}
    
    	/** Return sum of column's numbers on even column */
    	public static double sumColumn(double[][] m, int columnIndex) {
    		// Declare a variable and initialize it to zero 
    		double sumColumn = 0;
    		
    		// add all numbers in even row of array
    		for (int row = 0; row < m.length; row++) {
    			sumColumn += m[row][columnIndex];
    		}
    		
    		return sumColumn;
    	}
    

    Practice 8-2

    	/** 
    	 * 需求:求矩阵对角线数字之和
    	 * 分析: 这道题还是比较简单的前面我们做八皇后那道题相信大家已经懂了对角线上数据的处理
    	 * 		 首先读入矩阵数据(元素),然后在遍历二维数组,将第n行的matrix[n-1][n-1]元素加起来
    	 * 		 得到一个条主对角线的和.
    	 * 步骤:略(看分析) 
    	 * Time: 0: 30 AM
    	 * write code make :( for someone
    	 * Write code make :) for someone
    	 */
    	
    	/** Create main method */
    	public static void main(String[] args) {
    		// Read two dimensional arrays by getMatrix of method
    		double[][] matrix = getMatrix();
    		
    		// Display result
    		System.out.println("Sum of the elements in the major diagonal is " + sumMajorDiagonal(matrix));
    		
    	}
    
    	/** Return two dimensional arrays */  
    	// 此方法可以直接引用上面的getMatrix(),但是为了让大家清楚这个程序的编译运行,修改复制一下吧
    	public static double[][] getMatrix() {
    		// Create a Scanner
    		java.util.Scanner input = new java.util.Scanner(System.in);
    		
    		// Prompt the user to enter a 4-by-4 matrix row by row
    		System.out.println("Enter a 4-by-4 matrix row by row: ");
    		
    		// Create a arrays and row'length is 4, column'length is 4 of the matrix
    		double [][] matrix = new double[4][4];
    		
    		// Read and store data into arrays through user input
    		for (int row = 0; row < matrix.length; row++) {
    			for (int column = 0; column < matrix[row].length; column++) {
    				matrix[row][column] = input.nextDouble();
    			}
    		}
    		
    		return matrix;
    	}
    	
    	/** Return sum of numbers on the major diagonal */
    	public static double sumMajorDiagonal(double[][] m) {
    		// Declare a variables and initialize it to zero
    		double SumMajorDiagonal = 0;
    		
    		// Compute SumMajorDiagonal
    		for (int row = 0; row < m.length; row++) {
    			SumMajorDiagonal += m[row][row];
    		}
    		
    		// Return SumMajorDiagonal
    		return SumMajorDiagonal; 
    	}
    	
    

    各位实在不好意思
    Practice 8 - 3 略,真不愿往上翻 😦

    Practice 8-3 Omitted

    Practice 8-4

    	/**
    	 * 提醒: 在写每一段程序都要搞清楚程序的需求,这里题干都给了我们需求的解释, 所以我们的需求
    	 *       按照题目来写了,再者我们要对题目进行分析,最好用注释写出步骤,这是学每个计算机语
    	 *       言的很好的习惯。
    	 * 需求:计算每个雇员每周工作得小时数
    	 * 分析:这道题看似两颗星,其实我觉得很简单呀,当然这本书我还没遇到难题,但从程度上来说这
    	 * 		 道题也就值一个星;前面还是一样读入雇员得每天得工时数,然后计算每位雇员工时数这周
    	 * 		 得总数,然后进行降序排列
    	 * 
    	 * 步骤: 1:读入矩阵(数组)
    	 * 		 2:遍历数组计算每行得元素和
    	 * 		 3:将每行得元素和储存到一个新建的数组上去
    	 * 		 4:最后进行数组降序排序(冒泡排序)
    	 * 		 *:写了这么多是不是很清晰呢,写注释写的我想跳过这题;
    	 */
    	
    	/** Create main method */
    	public static void main(String[] args) {
    		// Store all employees' weekly hours in a two-dimensional array
    		int[][] matrix = {{2, 4, 3, 4, 5, 8, 8},
    						  {7, 3, 4, 3, 3, 4, 4},
    						  {3, 3, 4, 3, 3, 2, 2},
    						  {9, 3, 4, 7, 3, 4, 1},
    						  {3, 5, 4, 7, 3, 4, 1},
    						  {3, 4, 4, 6, 3, 4, 4},
    						  {3, 7, 4, 8, 3, 8, 4},
    						  {6, 3, 5, 9, 2, 7, 9}};
    		
    		int[][] sumHoursArrays = getSumOfPerLine(matrix);
    		int[][] downArrays = getDownSortArrays(sumHoursArrays);
    		
    		// Display result
    		for (int row = 0; row < downArrays.length; row++) {
    			System.out.println("The employee" + downArrays[row][1] + "'s number of sum of hours are "
    					+ downArrays[row][0]);
    		}
    	}
    
    	/** Return getSumOfPerLineArrays*/
    	public static int[][] getSumOfPerLine(int[][] matrix) {
    		// Create a two dimensional array
    		int[][]	sumHoursArrays = new int[matrix.length][matrix.length];
    		
    		// Compute per emplyees's weekly hours and numbering, then Store in new array
    		for (int row = 0; row < matrix.length; row++) {
    			int sumHours = 0;
    			// Compute
    			for (int col = 0; col < matrix[0].length; col++)
    				sumHours += matrix[row][col];
    			
    			// Store sum Of hours
    			sumHoursArrays[row][0] = sumHours;
    			// Store employees' numbering
    			sumHoursArrays[row][1] = row;
    		}
    		
    		// Return new array
    		return sumHoursArrays;
    	}
    
    	/** 这里是要对总小时数据存储的数组进行排序的,但是呢在调用方法排序 然后赋值 是不改变数组内容的,
    	 * 所以我们可以arraycopy复制一个新的数组,利用之前书中提到冒泡排序来进行降序排列,然后返回到
    	 * 主函数去
    	 */
    	/** Return down sort hours of method*/
    	public static int[][] getDownSortArrays(int[][] sumHoursArrays) {
    		// Create a new array
    		int[][] downSortHours = new int[sumHoursArrays.length][sumHoursArrays[0].length];
    		// Copy into new array
    		System.arraycopy(sumHoursArrays, 0, downSortHours, 0, sumHoursArrays.length);
    		
    		// Through two-dimensional array, and down sort to elements of per line
    		for (int row = 0; row < downSortHours.length; row++) {
    			for (int n = row + 1; n < downSortHours.length - 1; n++) { 
    				if (downSortHours[row][0] > downSortHours[n][0]) {  // Use bubble sort
    					// Two values of sumHours in swap
    					int temp = downSortHours[row][0];
    					downSortHours[row][0] = downSortHours[n][0];
    					downSortHours[n][0] = temp;
    					
    					// Two values of numbering in swap
    					int temp1 = downSortHours[row][1];
    					downSortHours[row][1] = downSortHours[n][1];
    					downSortHours[n][1] = temp1;
    				}
    			}
    		}
    		
    		// Return copyArray 
    		return downSortHours;
    	}
    

    Practice 8-4 Omitted
    这道题你们懂得,要略了,我直接写下面第五道题,因为第五题是第四题得变型题,你们要是刚学还是多写一下吧,这道题还是有意义的题

    Practice 8 -5

    /** 前言:突然感觉要做的事情好多呀,先把这章做完保证三个小时之内,但是要是自己敲就三个小时,还有
     *		   注释应该的要六个小时,前面三个题目就花了我一个小时 哎这道题其实很简单,我都不想动手了,
     *        算了为了伟大初学者觉得我是一个勤奋的人,十分钟解决了
     *  注意:本人为了速度,确实题目太多了,没注意优化我的代码,如果你们有好的建议留言跟我说一下,
     *		   我会有空,保证让大家看到更好的代码环境
     *  需求:两个矩阵相乘, 打印题目要求的结果
     *  分析:肯定是创建两个输出,把用户需要的数据一一储存在对应的数组,然后用两个数组按照题目给的公
     *  	   式得到第三个矩阵的数据,然后按照要求打印出来(本题稍微难那么一点点点点点点的就是打印部分
     *  步骤: 略(看分析,看题目)
     *  */
    
    /** Create main method */
    public static void main(String[] args) {
      	// Prompt the user to enter elements of matrix_a
    	System.out.print("Enter matrix1: ");
    	double[][] matrix1 = getMatrix();
    	
    	// Prompt the user to enter elements of matrix_b
    	System.out.print("Enter matrix2: ");
    	double[][] matrix2 = getMatrix();
    	
    	// Compute out matrix_c, and store in matrix_3
    	double[][] matrix3 = multiplyMatrix(matrix1, matrix2);
    	
    	// Display result
    	for (int row = 0; row < matrix1.length; row++) {
    		// Print matrix_a
    		printDisplay(matrix1, row);
    		// if loop is going on two times, we should print "+"
    		if (row == 1)
    			System.out.print("  *  ");
    		else  // Else blank space
    			System.out.print("     ");
    		// Print matrix_b
    		printDisplay(matrix2, row);
    		// if loop is going on two times, we should print "="
    		if (row == 1) 
    			System.out.print("  =  ");
    		else  // Else blank space
    			System.out.print("     ");
    		// Print matrix_c
    		printDisplay(matrix3, row);
    		
    		// Blank line on per line
    		System.out.println();
    	}
    	
    }
    
    /** Return print elements of per line */
    public static void printDisplay(double[][] x, int row) {
    	for(int n = 0; n < 3; n++)
    		// 这里我要说一下, 要用 printf 统一小数个数,不然打印结果很难看
    		System.out.printf("%.1f ", x[row][n]);
    	// Return none;
    	return;
    }
    
    /** Return input elements and store in matrix*/
    public static double[][] getMatrix() {
    	// Create a Scanner
    	java.util.Scanner input = new java.util.Scanner(System.in);
    	
    	// Create a 3-by-3 of matrix
    	double[][] matrix = new double[3][3];
    	
    	// Store in matrix
    	for (int row = 0; row < matrix.length; row++) {
    		for (int col = 0; col < matrix[row].length; col++) 
    			matrix[row][col] = input.nextDouble();
    	}
    	
    	// Return matrix
    	return matrix;
    }
    
    /** Return compute out matrix_a multiply matrix_b to result*/
    public static double[][] multiplyMatrix(double[][] matrix1, double[][] matrix2) {
    	// Create same as matrix_a's size of matrix_c
    	double[][] matrix3 = new double[matrix1.length][matrix1.length];
    	
    	// Compute out matrix_a multiply matrix_x, and store in matrix_c
    	for (int row = 0; row < matrix3.length; row++) {
    		for (int col = 0; col < matrix3[row].length; col++) {  // use formula
    			matrix3[row][col] = matrix1[row][0] * matrix2[0][col] + matrix1[row][1]  
    					* matrix2[1][col] + matrix1[row][2] * matrix2[2][col];
    		}
    	}
    	
    	// Return matrix_c
    	return matrix3;
    }
    

    Practice 8_20
    这道题目有更好解法请告知!

     public static void main(String[] args) {
            Scanner input = new Scanner(System.in); // 这个创建一个Scanner对象,
    
    
            String[][] array = new String[6][15];   // 这里是创建一个二位数组,colum是一个double数量+1, 因为colum是有 "|"和 "  " 组成的,
    
                for (int i = 0; i < array.length; i++) {	// 这里对二维数组储存 " | " 和 " " , 形成一个棋盘
                for (int j = 0; j < array[i].length; j++) {
                    if (j % 2 == 0 )
                        array[i][j] = "|";
                    else
                        array[i][j] = " ";
    
                }
            }
    
                for (int i = 0; i < array.length; i++) {     // 这里是开始之前打印一次棋盘
                     for (int j = 0; j < array[i].length; j++) {
                         System.out.print(array[i][j]);
                     }
                     System.out.println();
                }
                System.out.println("--------------");
    
            flag: {   // 这里一大段先标记一下
                for (int count = 0; count <= 42; count++){  //这里很简单利用一个for循环,因为输入只能输入42次,且每次Red和yellow交替
                    String s = null;  // 设置一个String,每次对它来回赋值 (R or Y)
                    if (count % 2 == 0)
                        s = "R";
                    else
                        s = "Y";
    
                    System.out.print("Drop a " + ((s == "R") ? "red" : "yellow")+ " disk at colum(0-6): "); // 打印标题
                    int number = input.nextInt(); // 输入用户所需的位置的数字
    
                    for (int i = array.length - 1; i >= 0; i--) {
                        /* 这里其实有点难理解,对用户输入的位置进行判断是否为 " " 如果为空,直接进行赋值,如果不为空 i-1,向上一个进行判断
                            直到 i-n 的位置 为空时,再进行赋值,是一个循环判断过程
                         */
    
                        if (array[i][number*2+1] == " ") {   //这里的 colum 要对应空格,有一个数学规律, 2n+1,这里也是进行判断的条件
                            array[i][number*2+1] = s;   //  如果为空进行赋值
                            break;  //赋值以后之间跳出小循环
                        }
                    }
    
                    for (int i = 0; i < array.length; i++) {  //这里是对每次大循环打印一次棋盘,这里没什么好讲的
                        for (int j = 0; j < array[i].length; j++) {
                            System.out.print(array[i][j]);
    
                        }
                        System.out.println();
                    }
                    System.out.println("--------------");
    
                    for (int i = 0; i < array.length ; i++) {  // 这里是利用两次小循环是检测过程
                        for (int j = 1; j < array[i].length; j+=2) {
                            if (array[i][j] != " ") {
                                if(newArray(array, i , j)) {  // 这里采用一个小方法
                                    System.out.println("The " + ((s == "R") ? "red" : "yellow") + " player won");  // 打印结果
                                    break flag; // 检测完Red或者Yellow 胜负结果就不用执行count的大循环了,这里flag 标记起到了作用,利用flag跳出大循环,结束本程序
                                }
                            }
                        }
                    }
                }
            }
        }
    
        public static boolean newArray(String[][] array, int i, int j) {
            String str = array[i][j];
    
            boolean boo1 = false;
            boolean boo2 = false;
            boolean boo3 = false;
            boolean boo4 = false;
    
            /*
               这里检测比较复杂,我们要知道规则就是 成列成行成对角线4个棋子相同则游戏结束
               表面上我们要判断八种情况,但其实我们只要判断四种情况
               第一种情况:右边 成行
                二      : 下面 成列
                三和四     : 斜右 对角线 和斜右 对角线
    
               首先要判断 当前输入的棋子输入在什么位置,
               再其位置要进行判断,
    
             */
            if (i + 3 < array.length) {  // 这里是判断棋子右边是否可以形成 成行或者 成斜右或斜左对角线
                if (j + 6 < array[i].length) // 判断斜右对角线
                    if (array[i][j]==str && array[i+1][j+2]==str && array[i+2][j+4]==str && array[i+3][j+6]==str)
                        boo1 = true; // 如果能,就返回true
                if (j - 6 > 0)  // 判断斜左对角线
                    if (array[i][j]==str && array[i+1][j-2]==str && array[i+2][j-4]==str && array[i+3][j+6]==str)
                        boo2 = true; // 如果能, 就返回一个true
    
                // 这里是判断是否成行
                if (array[i][j]==str && array[i+1][j]==str && array[i+2][j]==str && array[i+3][j]==str)
                    boo3 = true;  // 如果能 ,就返回一个true
            }
            else {  // 这里就是棋子不能成右边成行的情况下,它只有一种检测情况,就是斜左对角线
                if (j + 6 < array[i].length)
                    if (array[i][j]==str && array[i][j+2]==str && array[i][j+4]==str && array[i][j+6]==str)
                        boo4 = true; // 如果能,就返回一个true
            }
    
            // 最终我们只需对四种情况下,我们只要有一种检测情况为true,则返回true,游戏结
            return boo1 || boo2 || boo3 || boo4;
        }
    
    展开全文
  • Java语言程序设计基础篇第10版课后习题答案+完整源代码,直接导入eclipse即可运行
  • Introduction to Java Programming and Data Structures, Comprehensive Version, Global Edition,11ed,梁勇教授(Y.Daniel Liang)最新的教材,第11版,全网独家资源。原版高清pdf,可以打印,非扫描版,内含全部...
  • 本书是Java语言的经典教材,中文版分为基础篇和进阶篇,主要介绍程序设计基础、面向对象程序设计、GUI程序设计、数据结构和算法、高级Java程序设计等内容。本书以示例讲解解决问题的技巧,提供大量的程序清单,每章配...
  • 本书是Java语言的经典教材,中文版分为基础篇和进阶篇,主要介绍程序设计基础、面向对象程序设计、GUI程序设计、数据结构和算法、高级Java程序设计等内容。本书以示例讲解解决问题的技巧,提供大量的程序清单,每章配...
  • 本书是Java语言的经典教材,中文版分为基础篇和进阶篇,主要介绍程序设计基础、面向对象程序设计、GUI程序设计、数据结构和算法、高级Java程序设计等内容。本书以示例讲解解决问题的技巧,提供大量的程序清单,每章配...
  • 本书是Java语言的经典教材,中文版分为基础篇和进阶篇,主要介绍程序设计基础、面向对象程序设计、GUI程序设计、数据结构和算法、高级Java程序设计等内容。本书以示例讲解解决问题的技巧,提供大量的程序清单,每章配...
  • 学习编程最重要的还是要靠自己动手做练习,此文档是Java语言程序设计(梁勇)一书第21-30章完整的习题答案,可以很好地帮助我们学习提高!
  • 太多私信要我继续更新,之前我是看到12章大概,所以我就只更新12章和以后的章节。 Practice 12_1 public static void main(String[] args) { args = new String[] ... System.out.print("Java Calculator "); // ...
  • 注释:太多人催我更新,本来这第十四章至第十六章java GUI 对于一部分人(不是科班生没必要学的),理由主要是你实际用不太到,而就是太过于简单了,没必要写答案。可是呢,最简单的东西大家问我要代码往往最多,...
  • 1. 计算机中字节(byte)是最小的存储单位,1 byte = 8bit 2.内存 随机访问存储器 (RAM) 3. 代码风格 4. 从控制台读取输入/键盘输入 Scanner scanner = new Scanner(System.in);......
  • java编程基础习题答案(梁勇著,基础班+进阶版),项目exercise直接导入eclipse就可以看到答案了

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 495
精华内容 198
关键字:

java梁勇

java 订阅