JAVA面向对象编程题_0、从键盘上输入两个数,计算第一个数除以第二个数人结果,要求用异常处理的

1.给我一个字符串，例如I love java,输出： java love I

public class StringReverse {  
      
    public void swap(char[] arr, int begin, int end) {  
        while(begin < end) {  
            char temp = arr[begin];  
            arr[begin] = arr[end];  
            arr[end] = temp;  
            begin++;  
            end--;  
        }  
    }  
    //I love java  
    public String swapWords(String str) {  
        char[] arr = str.toCharArray();  
        swap(arr, 0, arr.length - 1);  
        int begin = 0;  
        for (int i = 1; i < arr.length; i++) {  
            if (arr[i] == ' ') {  
                swap(arr, begin, i - 1);  
                begin = i + 1;  
            }  
        }  
  swap(arr, begin, arr.length-1);
        return new String(arr);  
    }  
      
    public static void main(String[] args) {  
        String str = "I love java";  
        System.out.println(new StringReverse().swapWords(str));  
    }  
 
}  

 

 

1.输入一个正数n，输出所有和为n的连续正数序列。

分析：设定两个指针，min指向和为n的连续正数序列的最小值，max指向和为n的连续正数序列最大值。sum表示真正的和。
初始情况下,min、max和sum 都指向1.
当sum小于n时，max++；
当sum大于n时，min++;
当sum等于n时，输出整个序列。

public class a {
public static void getAns(int n) {
    int min = 1;
    int sum = 1;
    int max = 1;
    while(min <= n/2+1) {
        if(sum == n) {
            for(int k = min; k<=max; k++) {         
            System.out.println(k+"");
            }
            System.out.println();
            sum = sum - min;
            min ++;
            max ++;
            sum = sum+max;
        }
        if(sum > n) {
            sum = sum - min;
            min ++;
        } else {
            max ++;
            sum = sum + max;
        }
    }
}
public static void main(String[] args) {
    getAns(15);
}}

2.给定一个排好序的链表，删除链表中重复的结点，返回链表头指针。

分析：(1)链表中重复的结点不需要保留一个，要全部删除。
(2)因为相同的结点全部要删除，所以我们设定三个指针，node指向当前节点,prev指向前驱，还有一个指向后继结点。一旦遇到node和后继结点相等，就node++,知道没有重复的再移动prev.
(3)注意：头结点也可能有重复，所以也可能被删除，所以需要定义一个root指向头结点。

public class a {
    // 结点定义，包括当前结点的值和next指向
    private static class ListNode {
        private int val;
        private ListNode next;
 
        public ListNode() {
        }
 
        public ListNode(int val) {
            this.val = val;
        }
 
        public String toString() {
            return val + "";
        }
    }
 
    // 删除节点的函数
    public static ListNode delete(ListNode head) {
        if (head == null)
            return null;
        if (head.next == null)
            return head;
        // 定义一个临时的头结点，因为头结点也可能被删除
        ListNode root = new ListNode();
        root.next = head;
        ListNode prev = root;
        ListNode node = head;
 
        while (node != null && node.next != null) {
            if (node.val == node.next.val) {
            //若有连续相同的结点，则node要一直++
      while (node.next != null && node.next.val == node.val)
                    node = node.next;
                prev.next = node.next;
            } else {
                prev.next = node;
                prev = prev.next;
            }
            node = node.next;
        }
        return root.next;
    }
    //打印出来删除后的结果
    private static void print(ListNode head) {
        while (head != null) {
            System.out.print(head + "->");
            head = head.next;
        }
        System.out.println("null");
    }
 
    public static void main(String[] args) {
        // 按照结点的定义新建一个链表
        ListNode n1 = new ListNode(1);
        ListNode n2 = new ListNode(1);
        ListNode n3 = new ListNode(2);
        ListNode n4 = new ListNode(2);
        ListNode n5 = new ListNode(2);
        ListNode n6 = new ListNode(3);
        ListNode n7 = new ListNode(5);
 
        n1.next = n2;
        n2.next = n3;
        n3.next = n4;
        n4.next = n5;
        n5.next = n6;
        n6.next = n7;
        n7.next = null;
        //调用delete函数，传入n1的值，当成头结点
        ListNode result = delete(n1);
        print(result);
 
    }
}

3.对于一个有序数组，我们通常采用二分查找的方式来定位某一元素，请编写二分查找的算法，在数组中查找指定元素。
给定一个整数数组A及它的大小n，同时给定要查找的元素val，请返回它在数组中的位置(从0开始)，若不存在该元素，返回-1。若该元素出现多次，请返回第一次出现的位置。
分析：重点在返回第一次出现的位置。

public class c {
    public static int getPos(int[] A, int n, int val) {
        int low = 0, high = n - 1, mid;
        if (n == 0 || A == null)
            return -1;
        while (low <= high) {
            mid = (low + high) / 2;
    //当第一次找出相等的位置后需要继续向前查找，最后返回第一次出现的位置
            if (val == A[mid]) {
                for(int j = mid; j >= 0; j--) {
                    if(A[j] != A[mid]) {
                        mid = j + 1;
                        break;
                    }
                    else if(A[j] == A[mid]) {
                        mid = j;
                        continue;
                    }
                }
                return mid;
 
            } else if (val < A[mid])
                high = mid - 1;
            else
                low = mid + 1;
        }
        return -1;
    }
 
    public static void main(String[] args) {
        int A[] = { 4, 4, 5, 5, 5, 5 };
        int val = 4;
        int n = A.length;
        int result = getPos(A, n, val);
        System.out.println(result);
    }
}

4.对于一个字符串，请设计一个高效算法，找到第一次重复出现的字符。
给定一个字符串(不一定全为字母)A及它的长度n。请返回第一个重复出现的字符。保证字符串中有重复字符，字符串的长度小于等于500。

方法1：这是前辈给出的算法，利用HashSet的特性，即不允许重复放入元素，所以一旦检测到重复元素就返回false。对于本道题来说，这种方法简洁且容易理解，能高效实现功能，但是这种方法普适性较差。

 
import java.util.HashSet;
 
public class g {
    public static char findFirstRepeat(String A, int n) {
        HashSet hs=new HashSet();
        int length=A.length();
        //利用toCharArray()将String类型转化为char类型
        char[] a=A.toCharArray();
        for(int i=0;i < length;i++)
            {
            boolean b=hs.add(a[i]);//通过往hashset塞值（hashset不准有重复元素），判断当前一段数据中是否有重复元素，一但有，立刻返回
                if(b==false)
                {
                 return a[i];
            }
        }
        return'0';
    }
    public static void main(String[] args) {
        String A = "qywyer23tdd";
        int n = A.length();
        char b = findFirstRepeat(A, n);
        System.out.println(b);
    }
}

方法2：利用了哈希存储，将给定字符串以键值对形式存储在哈希Map中，key就是每一个字符，value就是每个字符出现的次数。存好后再按顺序遍历Map，找出第一次出现次数不为1的即可。返回。
注意：基于hash的存储是很高效的一种方式，存储键值对方便查找，可以根据key查找value,或者根据value查找key，或者查找特殊的字符等。

延伸：返回第一个只出现一次的字符，返回最后一个出现次数不为1的字符，返回所有出现次数为1的字符或者出现次数不为1的字符，返回给定出现次数的字符等等。

import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
 
public class g {
    private static void findFirstRepeat(String A, int n) {
        int sum = 1;//新插入的key-value给value赋初始值都为1
        //用LinkedHashMap来存储键值对
        //HashMap插入和输出顺序不一样
        //但LinkedHashMap插入和输出顺序相同，即先存的先显示，也就是尾插
//HashSet要求不能存重复元素，但HashMap和LinkedHashMap可以存重复元素。
             Map<String, Integer> hashMap = new LinkedHashMap
                                        <String, Integer>();
        for (int i = 0; i < n; i++) {
    //将main中传过来的String类型参数一个字符一个字符的转化为char类型，方便处理。
            char item = A.charAt(i);
//再将每一个char类型的字符转化为String类型。这一步操作和上一步操作作用是分离出每一个字符。
            String item2 = String.valueOf(item);
            String key = item2;
            // 判断是否包含指定的键值
            boolean contains = hashMap.containsKey(key);    
            if (contains) { // 如果条件为真
                sum++;
                hashMap.put(item2, sum);// 输出信息         
            } else {
                sum = 1;
                hashMap.put(item2, sum);            
            }
        }   
        //输出存进哈希表中的所有键值对
         System.out.println(hashMap);
         //以下是通过给定的value值反查key的过程
         //将所有的键值对存在一个entrySet中
         //遍历entrySet,若找到value等于给定的value值，则将其对应key值存在keyList中。
         List<String> keyList = new ArrayList<String>();  
            for (Entry<String, Integer> e : hashMap.entrySet()) {  
                if (MathUtil.compare(e.getValue(),2) >= 0) {  
                    keyList.add(e.getKey());  
                }  
            }  
            //最后遍历keyList，输出第一次出现的key即可。
            for (String i : keyList) {  
                System.out.println(i);
                break;
            } 
    }
    public static void main(String[] args) {
        String A = "qywyer2333333333tdd";
        int n = A.length();
        findFirstRepeat(A, n);      
    }
}

关于类型转化问题：

(1)String---------》char / char[ ]
String str = "ab";
char str1 = str.charAt(0);  //得到a
char str2 = str.charAt(1);  //得到b
 
char[ ] str3 = str.toCharArray();
System.out.println (Arrays.toString(str3));
 
(2)char / char[]-----------》String
char m = 'a';
String str = String.valueOf(m);
String str2 = m + " ";
 
char[] m = {'a','b'};
String str3 = String.copyValueOf(m);
String str4 = new String(m);
 
(3)int -----------》 String
int i;
String s = String.valueOf(i);
String s = Integer.toString(i);
String s = "" + i;
 
(4)String ----------》 int
 
int i = Integer.parseInt([String]); 
i = Integer.parseInt([String],[int radix]);
int i = Integer.valueOf(my_str).intValue();
 

关于哈希存储的处理方案(本人亲试！) ：

(1)根据key来查找，判断是否包含给定的key。
         boolean contains = hashMap.containsKey(key); 
            if (contains) { // 如果条件为真
                System.out.println("存在"+key);
            } else {
                System.out.println("不存在" + key);
            }
(2)根据value来查找，判断是否包含给定的value.
  boolean contains = hashMap.containsValue(Value); 
            if (contains) { // 如果条件为真
                System.out.println("存在"+value);
            } else {
                System.out.println("不存在" +value);
            }
(3)利用keySet遍历所有的key值。
 
for (Object key : hashMap.keySet()) {
System.out.println("key= " + key + " value " + hashMap.get(key));
    }

 

1.合并两个排序的链表
思路：定义两个指针，一个指向list1,一个指向List2,定义一个新链表，List1和list2中哪个小就复制到新链表中。注意判断list1和list2是否为空！！！
本题是利用递归来实现的。

/*
public class ListNode {
    int val;
    ListNode next = null;
 
    ListNode(int val) {
        this.val = val;
    }
}*/
public class Solution {
    public ListNode Merge(ListNode list1,ListNode list2) {
       if(list1 == null) {
           return list2;
       } 
       if(list2 == null) {
           return list1;
       } 
       ListNode s = null;
        if(list1.val < list2.val) {
             s = list1;
           s.next =  Merge(list1.next, list2);
        } else if(list1.val >= list2.val) {
            s = list2;
            s.next = Merge(list1, list2.next);
        }
        return s;
    }
}

处理二进制问题：
两个int32整数m和n的二进制表达，有多少个位(bit)不同么？
(1)m^n后，将结果赋值给一个String类型的变量，循环遍历变量的每一位，看是否等于1.
(2)m^n后，将二进制结果的最后一位&1,然后将二进制右移。

public class Solution {
    /**
     * 获得两个整形二进制表达位数不同的数量
     * 
     * @param m 整数m
     * @param n 整数n
     * @return 整型
     */
    public int countBitDiff(int m, int n) {
 
        int x = m^n;
        int y = 0;
        while(x>0) {
            if((x&1) == 1) {
                y+=1;
            }
           x= x>>1;
        }
        return y;
    }
}

水仙花问题：水仙花，即给定一个三位数，每一位的数字立方加起来等于这个数本身。
解析：

import java.util.Scanner;
public class Solution {
         public static void main(String[] args) {
         Scanner san = new Scanner(System.in);
         //从键盘输入最小值
         int min = san.nextInt();
         //从键盘输入最大值
         int max = san.nextInt();
         for(int mid = min; mid < max; mid++) {
         int a = mid/100;
         int b = mid%10;
         int c = mid%100/10;
         int sum = a*a*a + b*b*b + c*c*c;
         if(sum == mid) {
         System.out.println(mid);
         }
         }
         }
}

题目：从键盘输入m和n，定义n是第一个数，之后的每个数都是前一个的平方根
，一共有m个数，计算总和。

import java.lang.Math;
import java.util.Scanner;
 
public class a {
    public static void main(String[] args) {
        //求平方根 
        Scanner scan = new Scanner(System.in);
        float n = scan.nextFloat();
        int m = scan.nextInt();
        float sum = n;
        for(int i=2;i<=m;i++) {
             sum += Math.sqrt(n);
             n = (float) Math.sqrt(n);
        }
        System.out.println("sum=" +sum);
    }
}

题目：Java的一维数组在不知道长度的情况下怎样声明？

(1) 不知道长度，所以不能直接声明大小

•  

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
 
public class a {
    public static void main(String[] args) {
    //用ArrayList来实现添加数据
        List<Integer> list = new ArrayList<Integer>(); 
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入数组");
        //给定一个while循环
        //保证输入一串数字，直接接收，并添加到list中，当输入0时结束输入
        while(true) {
        int a = scanner.nextInt();
        if(a==0) {
            break;
        } else {
            list.add(a) ;
        }
        }
        int size = list.size();
        //将list转成int型数组
        Integer[] array = (Integer[])list.toArray(new Integer[size]);   
        //输出int型数组。
        for(int i=0;i<array.length;i++){ 
          System.out.print(array[i]+" "); 
        } 
    }
}

这样就得到一个从键盘输入的Int型数组，接下来就可以对数组进行各种操作。
符合一般情况下的需要多组测试用例的情况。

题目：给定一个正整数，编写程序计算有多少对质数的和等于这个输入的正整数，并输出结果，输出值小于1000.
测试用例：
输入：10
输出：2 （(3,7) 和（5，5））。

 
import java.util.Scanner;
 
public class cc {
 
    private static int cout(int number) {
        int count = 0;
        for (int i = 2; i < number; i++) {
            for (int j = 2; j <= number / 2; j++) {
                if (isPrime(i) && isPrime(j) && (i + j) == number) {
                    count++;
                }
            }
        }
        return count;
    }
 
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入给定的数字");
        int a = scanner.nextInt();
        int count = cout(a);
        System.out.println("count=" + count);
 
    }
 
    public static boolean isPrime(int number) {
        if (number < 2) {
            return false;
        }
        for (int i = 2; i < number; i++) {
            if (number % i == 0) {
                return false;
            } else {
                continue;
            }
        }
        return true;
    }
}

2 . 题目：二分查找，在左区间输出0，右区间输出1.
逐渐逼近，保留6位。
注意特殊输入：
(1) key值小于输入临界最小值或者大于临界最大值。
(2) 临界最小值大于临界最大值。
(3) 两个临界值都为0，输出0。

 
 
import java.util.Scanner;
 
public class cc {
 
    public static int comp(int key, int num) {
        if (key >= num) {
            return 1;
        } else {
            return 0;
        }
    }
 
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入最小临界值");
        int a = scanner.nextInt();
        System.out.println("请输入最大临界值");
        int b = scanner.nextInt();
        System.out.println("请输入需要比较的值");
        int key = scanner.nextInt();
        if (key < a || key > b) {
            System.out.println("error");
        } else if (key == 0 && a == 0 && b == 0) {
            System.out.println("error");
        } else {
            while (a <= b) {
                for (int i = 0; i < 6; i++) {
                    int num;
                    num = (a + b) / 2;
                    System.out.println("num=" + num);
                    int s = comp(key, num);
                    if (s == 0) {
                        b = num;
                        System.out.println("0");
                    } else {
                        a = num;
                        System.out.println("1");
                    }
                }
                break;
            }
        }
 
    }
}

题目：镜像字符串，给定两个字符串，判断第二个是否为第一个的镜像字符串，是返回yes，否返回no.

import java.util.Scanner;
 
public class b {
 
    public static Boolean count(String str1, String str2) {
        int p1 = 0;
        int p2 = 0;
        char[] st1 = str1.toCharArray();
        char[] st2 = str2.toCharArray();
        for (int i = 0; i < st1.length; i++) {
            if (st1[i] == st2[0]) {
                p1 = i;
            }
        }
 
        while (p1 < st1.length && p2 < st2.length) {
            if (st1[p1] == st2[p2]) {
                if (p1 == st1.length) {
                    p1 = -1;
                }
                p1++;
                p2++;
                continue;
            } else {
                return false;
            }
        }
        return true;
    }
 
    public static void main(String[] args) throws Exception {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入字符串");
        String str1 = scanner.next();
        String str2 = scanner.next();
        if(str1.length()-str2.length()!=0) {
            System.out.println("no");
            return;
        }
        if (str1 == null || str1.length() <= 0 || str2 == null
                || str2.length() <= 0) {
            System.out.println("error");
        }
        Boolean num = count(str1, str2);
        if (num.equals(true)) {
            System.out.println("yes");
        } else {
            System.out.println("no");
        }
    }
}

 

1、编写程序实现对给定的 4 个整数从大到小的顺序排列。

<strong>package HomeWork01;
import java.util.Scanner;
 
public class HomeWork01 {
	static int number=4;    	//输入4个数存放在数组中                    
    static int[] t1 = new int[number];            
	public static void main(String[] args) {
		HomeWork01 jiejie=new HomeWork01();
		jiejie.shunxun();
	}
	void shunxun(){
		        System.out.println("请输入4个数：");
		        Scanner in_t1 = new Scanner(System.in);//循环输入数组
		        for(int i=0;i<number;i++){
		            t1[i]=in_t1.nextInt();}		   
		        for (int i = 0; i < t1.length; i++) {
		            int pos = i;
		            for (int j = i + 1; j < t1.length; j++) {
		                if (t1[pos] > t1[j])
		                    pos = j;
		            }
		            if (pos != i) {
		                t1[i] = t1[i] + t1[pos];
		                t1[pos] = t1[i] - t1[pos];
		                t1[i] = t1[i] - t1[pos];
		            }
		        }
		  	        
		        for (int i = t1.length - 1; i >= 0; i--)
		            System.out.print(t1[i] + "\t");
	}
}
</strong>

 

2、编写程序求一元二次方程的根。

<strong>package HomeWork02;
import java.util.Scanner;
public class HomeWork02
//△=b^2-4ac的值,若△小于0,一元二次方程无根.若△等于0,一元二次方程有两个相等的根.若△大于0,一元二次方程有两个不相等的实数根
	{
	public static void main(String [] args){
	Scanner sc = new Scanner(System.in);
	System.out.println("输入2次方的系数");
	int a = sc.nextInt();
	System.out.println("输入1次方的系数");
	int b = sc.nextInt();
	System.out.println("输入0次方的系数");
	int c = sc.nextInt();
	if((b*b - 4*a*c)<0){		//	判断方程是否有解
		System.out.println("方程无解！");
		return;
	}
	else{
		System.out.println("方程有解！");
	}
	double x1 = (-b + Math.sqrt(b*b - 4*a*c))/2*a;
	double x2 = (-b - Math.sqrt(b*b - 4*a*c))/2*a;
	System.out.println("根分别是 " + x1 + "\t" + x2);
	}
}
</strong>

 

 

3、编写程序，输入一个字符，判断它是否为小写字母，如果是，将它转换成大

写字母，否则，不转换。

<strong>package HomeWork03;
import java.util.Scanner;
public class HomeWork03 {
	public static void main(String[] args) {
		//小写字母的ascll值为97-122
		//大写字母的ascll值为65-90
		System.out.println("请输入一个字母：\n");
		Scanner input = new Scanner(System.in);
		char zimu=input.next().charAt(0);
          if (zimu>=97&&zimu<=122){			//判断是否是小写字母
        	  System.err.println("该字母是小写字母");
        	  zimu=(char) (zimu-32);		//如果是小写字母则 将其转换成大写字母
        	  System.err.println("转换之后的大写字母是："+zimu);
          } 
          else{
        	 System.out.println("该字母不是小写字母！");       	 
          }
	}	
}
</strong>

 

4、输入 3 个正数，判断能否构成一个三角形。

<strong>package HomeWork04;
import java.util.Scanner;
 
public class HomeWork04 {
	public static void main(String [] args){
	int a;
	int b;
	int c;
	System.out.println("请输入三个正整数：");
	Scanner in=new Scanner(System.in);
	a=in.nextInt();
	b=in.nextInt();
	c=in.nextInt();
	
	if(a<=0||b<=0||c<=0)
	{
		System.out.println("输入的必须是正整数！");
	}
	if((a+b)>c&&(a+c)>b&&(b+c)>a)
	{
		System.out.println("能构成三角形！");
	}
	else{
		System.out.println("不能构成三角形！");
	}
	}
	}
</strong>

 

5、编写程序，对输入的年、月、日，给出该天是该年的第多少天？

<strong>package HomeWork05;
import java.util.Scanner;
public class HomeWork05 {
public static void main(String[]args){
	Scanner sc =new Scanner(System.in);
	System.out.print("年");
	int year=sc.nextInt();
	System.out.print("月");
	int month=sc.nextInt();
	System.out.print("日");
	int day=sc.nextInt();
	int days=0;
	switch(month){
		case 12:days+=30;
		case 11:days+=31;
		case 10:days+=30;
		case 9:days+=31;
		case 8:days+=31;
		case 7:days+=30;
		case 6:days+=31;
		case 5:days+=30;
		case 4:days+=31;
		case 3:
			if((year%4==0&&year%100!=0)||(year%400==0)){
				days+=29;
				}
			else{
				days+=28;
				}
		case 2:days+=31;
		case 1:days+=day;
	}
		System.out.print("第" + days + "天");
}
}
</strong>

 

6、编写程序，从键盘输入一个 0~99999 之间的任意数，判断输入的数是几位

数？

<strong>package HomeWork06;
import java.util.Scanner;
public class HomeWork06 {
public static void main(String[]args){
	
	Scanner sc =new Scanner(System.in);
	System.out.print("请输入一个0~99999 之间的任意数");
	int number=sc.nextInt();
	if(number/10000>=1&&number/10000<10){
		System.out.println(number+"\t是5位数");
	}
	else if(number/1000>=1){
		System.out.println(number+"\t是4位数");
	}
	else if(number/100>=1){
		System.out.println(number+"\t是3位数");
	}
	else if(number/10>=1){
		System.out.println(number+"\t是2位数");
	}
	else if(number/1>=1){
		System.out.println(number+"\t是1位数");
	}
	}
}
</strong>

 

7、编写程序，给定一个学生成绩，给出相应等级：

90~100 优秀

80~89 良好

70~79 中等

60~69 及格

0~59 不及格

<strong>package HomeWork07;
import java.util.Scanner;
public class HomeWork07 {
 
	public static void main(String[] args) {
		HomeWork07 jiejie=new HomeWork07();
		jiejie.chengjie();
 
	}
	void chengjie(){
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入学生成绩：");
		int a = sc.nextInt();
		if(a>=90&&a<=100){
			System.out.println("该学生的成绩是"+a+"\t成绩优秀");
		}
		else if(a>=80&&a<90){
			System.out.println("该学生的成绩是"+a+"\t成绩良好");
		}
		else if(a>=70&&a<80){
			System.out.println("该学生的成绩是"+a+"\t成绩中等");
		}
		else if(a>=60&&a<70){
			System.out.println("该学生的成绩是"+a+"\t成绩及格");
		}
		else{
			System.out.println("该学生的成绩是"+a+"\t成绩不及格");
		}
	}
 
}
</strong>

 

8、编写程序，对输入的一个整数，按相反顺序输出该数。例如，输入为 3578，

输出为 8753。

<strong>package HomeWork08;
import java.util.Scanner;
 
public class HomeWork08 {
 
	public static void main(String[]args){
		Scanner sc =new Scanner(System.in);
		System.out.println("请输入一个整数：");
		int read = sc.nextInt();
		//方法一     reverse()API
		System.out.println("方法一：");
		StringBuilder sb  =  new StringBuilder(String.valueOf(read));
		System.out.println(sb.reverse());
		//方法二   将字符串转换成字符数组，反序输出
		String str= read +"";
		char fuzu[]=str.toCharArray();
		String temp="";
		for(int a=fuzu.length-1;a>=0;a--){
			temp=temp+fuzu[a];
		}
		System.out.println("方法二：");
		System.out.println(temp);
		
}
}
</strong>

 

9、用 while 循环，计算 1~200 之间所有 3 的倍数之和。

<strong>package HomeWork09;
 
public class HomeWork09 {
 
	public static void main(String[] args) {
		// 用while循环，计算1~200之间所有3的倍数之和。 
		int a=1;
		int sum=0;
		while(a<=200){
			if(a%3==0){
				sum=sum+a;
			}
			a++;
		}
		System.out.println("1~200之间所有3的倍数之和为:"+sum);
	}
}
</strong>

 

10、编写程序，输出 200~500 之间的所有素数。

<strong>package HomeWork10;
public class HomeWork10 {
	public static void main(String[] args) {
		int num=200;
		while (num<=500) {
			boolean tag=true;		//素数标记
			for(int d=2;d<=num-1;d++){
				if(num % d==0){
					tag=false;
					break;
				}
			}
			if(tag){				//如果是素数
				System.out.println(num);
			}
			num++;
		}
	}
}
</strong>

 

11、编写程序解决“百钱买百鸡”问题。公鸡五钱一只，母鸡三钱一只，小鸡

一钱三只，现有百钱欲买百鸡，共有多少种买法？

<strong>package HomeWork11;
public class HomeWork11 {
	public static void main(String[] args) {
		/* 、编写程序解决“百钱买百鸡”问题。
		 * 公鸡五钱一只，母鸡三钱一只，
		 * 小鸡 一钱三只，
		 * 现有百钱欲买百鸡，共有多少种买法？ */
		for(int g=0;g<=20;g++){
			for(int m=0;m<=33;m++){
				for(int x=0;x<=100-g-m;x++){
					if(x % 3==0 && 5*g+m*3+x/3 == 100 && g+m+x ==100){
						System.out.println("公鸡"+g+"只母鸡"+m+"只小鸡"+x+"只");
					}
				}
			}
		}
	}
}
</strong>

 

12、使用循环语句输出下面的图形。

#

# # #

# # # # #

# # # # # # #

# # # # # # # # #

<strong>package HomeWork12;
public class HomeWork12 {
	public static void main(String[] args) {
		int aa=-1;
		for( int a=0;a<5;a++){
			aa+=2;
			for(int b=1;b<=aa;b++){	
				System.out.print( "#"  );
			}
			System.out.println();}
		
	}
}
</strong>

 

13、验证“鬼谷猜想”：对任意自然数，若是奇数，就对它乘以 3 再加 1；若是

偶数，就对它除以 2，这样得到一个新数，再按上述计算规则进行计算，一直进

行下去，最终必然得到 1。

<strong>package HomeWork13;
import java.util.Random;;
public class HomeWork13 {
	public static void main(String[] args) {
		/*
		 * 验证“鬼谷猜想”：对任意自然数，若是奇数，
		 * 就对它乘以3再加1；若是 偶数，就对它除以2，
		 * 这样得到一个新数，
		 * 再按上述计算规则进行计算，
		 * 一直进 行下去，最终必然得到1。 */
		int num;
		Random rd=new Random();
		//Integer.MAX_VALUE为最大的整数
		num=1+rd.nextInt(Integer.MAX_VALUE);//产生数的范围-2[31]----2[31]-1
		//System.err.println(rd.nextInt(100));//产生数>=0且<100
		System.out.println("原本的数为"+num);
		while(num!=1){
			System.out.println("产生的新数是"+num);
			if(num%2==0){
				//偶数
				num=num/2;
			}
			else{
				num=num*3+1;
			}
		}
		System.out.println(num);
	}
}
</strong>

 

14、编程求 1~10000 之间的所有“完全数”，完全数是该数的所有因子之和等于该数的数。例如，6 的因子有 1、2、3，且 6=1+2+3，所以 6 是完全数。

<strong>package HomeWork14;
 
public class HomeWork14 {
	public static boolean isyinzi(int num ){
		int sum=0;
		//判断一个整数是不是一个完全数
		for(int d=num-1;d>=1;d--){
			if(num%d==0){
				sum+=d;
			}
		}
		return sum==num;
	}
 
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		/*
		 * 编程求1~10000之间的所有“完全数”，
		 * 完全数是该数的所有因子之和等
		 * 于该数的数。例如，6的因子有1、2、3，
		 * 且6=1+2+3，所以6是完全数*/
		for(int a=1;a<=1000;a++){
			int num=a;
			if(isyinzi(num)){
				System.out.println(num);
			}
		}
 
	}
 
}
</strong>

 

 

15、一个整数的各位数字之和能被 9 整除，则该数也能被 9 整除。编程验证给

定的整数能否被 9 整除。

<strong>package HomeWork15;
import java.util.Random;
public class HomeWork15 {
	public static void panduan(int num){
		int b=num/100;		//百位数
		int s=num%100/10;	//十位数
		int g=num%10;		//个位数
		if(num%9==0){
			System.out.println(num+"能被9整除");
			if((b+s+g)%9==0){
				System.out.println("同时"+num+"的各个位数之和也能被9整除");
			}
			else{
				System.out.println("但是"+num+"的各个位数之和不能被9整除");
			}
		}
		else 
			System.out.println("next test!");
		
	} 
	public static void main(String[] args) {
		Random rd=new Random();
		int shu=10+rd.nextInt(90);
		shu =shu *9;
		panduan(shu);
	}
}
</strong>

 

16、猴子吃桃问题。猴子第一天摘下若干个桃子，当时就吃了一半，还不过瘾，

就又吃了一个。第二天又将剩下的桃子吃掉一半，又多吃了一个。以后每天都吃

前一天剩下的一半零一个。到第 10 天在想吃的时候就剩一个桃子了,求第一天共

摘下来多少个桃子？

<strong>package HomeWork16;
public class HomeWork16 {
public static void main(String[] args) {
	int total=1;
	int day=10;
	for (int i = 10; i >0; i--) {
		System.out.println("第"+day+"天，有桃子"+total+"颗");
		total=(total+1)*2;
		day--;	
	}
}
}
</strong>

 

17、水仙花数是指一个 n 位数 ( n≥3 )，它的每个位上的数字的 n 次幂之和等

于它本身。（例如：1^3 + 5^3 + 3^3 = 153）。编程求出所有三位的水仙花数。

<strong>package HomeWork17;
public class HomeWork17 {
	public static void main(String[] args) {
		for(int num=100;num<1000;num++){
			if(isshuixian(num)){
				System.out.println(num);
			}
		}
	}
	//判断一个数是不是水仙花数
	public static boolean isshuixian(int num){
		int b=num/100;
		int s=num%100/10;
		int g=num%10;
		return Math.pow(b, 3)
				+Math.pow(s, 3)
				+Math.pow(g, 3)==num?true:false;
	}
}
</strong>

 

18、已知 XYZ+YZZ=532，其中，X、Y、Z 为数字，编程求出 X、Y 和 Z 的值。

19、古典问题：有一对兔子，从出生后第 3 个月起每个月都生一对兔子，小兔

子长到第三个月后每个月又生一对兔子，假如兔子都不死，问每个月的兔子总数

为多少？

<strong>package HomeWork19;
 
import java.util.Scanner;
 
public class HomeWork19 {
	/*
	 * 古典问题：有一对兔子，
	 * 从出生后第3 个月起每个月都生一对兔子，
	 * 小兔 子长到第三个月后每个月又生一对兔子，
	 * 假如兔子都不死，
	 * 问每个月的兔子总数 为多少？ */
	public int rubbit(int mon){
		if(mon<=2){
			return 1;
		}
		else{
			return rubbit(mon-1)+rubbit(mon-2);
		}
	}
	public static void main(String[] args) {
		int r=1;
		int rr=1;
		int rrr=1;
		System.out.println("方法一：");
		for(int a=1;a<=12;a++){
			//12个月
			if(a<=2){
				r=1;
			}
			else{
				//当前月等于前两个月之和
				r=rr+rrr;
				rrr=rr;
				rr=r;
			}
			System.out.println(r*2);
		}
		System.out.println("方法二,求指定月份的兔子数量：");
		HomeWork19 jisuan=new  HomeWork19();
		System.out.println("请输入月份：");
		Scanner sc=new Scanner(System.in);
		int yue=sc.nextInt();
		System.out.println(yue+"月份的兔子数量是"+(jisuan.rubbit(yue))*2);
	}
}
</strong>

 

20、将一个正整数分解质因数。例如：输入 90，打印出 90=2*3*3*5。

<strong>package HomeWork20;
import java.util.Scanner;
public class HomeWork20 {
	public static void main(String[] args) {
		System.out.println("请输入一个整数：");
		Scanner sc=new Scanner(System.in); 
		int num=sc.nextInt();
		System.out.println(num+"的质因数有：");
		for(int i=2;i<num;i++){
			while(num%i==0){
				num/=i;
				System.out.print(i+" ");
			}
		}
		System.out.print("  "+num);
	}
 
}</strong>

 

01.类的成员变量 猜数字游戏一个类A有一个成员变量v有一个初值100。定义一个类对A类的成员变量v进行猜。如果大了则提示大了小了则提示小了。等于则提示猜测成功。

 
import java.util.*;
public class lianxi
{
    public static void main(String[] dsa)
    {
    A a=new A();
    Scanner input=new Scanner(System.in);
    while (1==1)
    {
        System.out.println("请猜测数字");
        int i=input.nextInt();
        if (i<a.v)
        {
            System.out.println("小了");
            continue;
        }
        else if (i>a.v)
        {
            System.out.println("大了");
            continue;
        }
        else
        {
            System.out.println("恭喜你猜对了！");
            break;
        }
    }
    }
}
class A
{
    public int v=100;
}

02.类的成员变量 请定义一个交通工具(Vehicle)的类其中有: 属性速度(speed)体积(size)等等 方法移动(move())设置速度(setSpeed(int speed))加速speedUp(),减速speedDown()等等. 最后在测试类Vehicle中的main()中实例化一个交通工具对象并通过方法给它初始化speed,size的值并且通过打印出来。另外调用加速减速的方法对速度进行改变。

 
public class Vehicle
{
    private int speed;
    private String size;
    public void move()
    {
    System.out.println("i'm moving");
    }
    public void setSpeed(int speed)
    {
        System.out.println("now i'm running with"+speed+"per hour");
    }
    public void speedUp()
    {
        Vehicle v=new Vehicle();
        v.setSpeed(1000);
    }
    public void speedDown()
    {
    Vehicle v=new Vehicle();
        v.setSpeed(20);
    }
    public static void main(String[] dsa)
    {
    Vehicle v=new Vehicle();
    v.speed=100;
    v.size="50/m^3";
    System.out.println("the initial speed is"+v.speed+"and my size is "+v.size);
    v.speedUp();
    v.speedDown();
    }
}

03.类的成员变量与方法、构造方法 在程序中经常要对时间进行操作但是并没有时间类型的数据。那么我们可以自己实现一个时间类来满足程序中的需要。 定义名为MyTime的类其中应有三个整型成员时hour分minute秒second为了保证数据的安全性这三个成员变量应声明为私有。 为MyTime类定义构造方法以方便创建对象时初始化成员变量。 再定义diaplay方法用于将时间信息打印出来。 为MyTime类添加以下方法 addSecond(int sec) addMinute(int min) addHour(int hou) subSecond(int sec) subMinute(int min) subHour(int hou) 分别对时、分、秒进行加减运算。

 
public class MyTime
{
    private int hour;
    private int minute;
    private int second;
    public MyTime(int x,int y,int z)
    {
    this.hour=x;
    this.minute=y;
    this.second=z;
    }
    public void display()
    {
    System.out.println("the time is "+this.hour+":"+this.minute+":"+this.second);
    }
    public void addHour(int hou)
    {
    this.hour=this.hour+hou;
    }
    public void addSecond(int sec)
    {
    this.second=this.second+sec;
    }
    public void addMinute(int min)
    {
    this.minute=this.minute+min;
    }
    public void subHour(int hou)
    {
    this.hour=this.hour-hou;
    }
    public void subMinute(int min)
    {
    this.minute=this.minute-min;
    }
    public void subSecond(int sec)
    {
    this.second=this.second-sec;
    }
}

【练习题】04.构造方法 编写Java程序模拟简单的计算器。 定义名为Number的类其中有两个整型数据成员n1和n2应声明为私有。编写构造方法赋予n1和n2初始值再为该类定义加addition、减subtration、乘multiplication、除division等公有成员方法分别对两个成员变量执行加、减、乘、除的运算。 在main方法中创建Number类的对象调用各个方法并显示计算结果。

 
public class Number
{
    private int x;
    private int y;
    public Number(int x,int y)
    {
    this.x=x;
    this.y=y;
    }
    public void plus()
    {
    System.out.println("the result is:"+(this.x+this.y));
    }
    public void except()
    {
    System.out.println("the result is :"+(this.x-this.y));
    }
    public void multiplication()
    {
    System.out.println("the result is :"+(this.x*this.y));
    }
    public void division()
    {
    System.out.println("the result is :"+(this.x/this.y));
    }
    public static void main(String[] dsa)
    {
    Number lian=new Number(4,4);
    lian.plus();
    lian.except();
    lian.multiplication();
    lian.division();
    }
}

【练习题】05.构造方法 编写Java程序用于显示人的姓名和年龄。 定义一个人类Person该类中应该有两个私有属性姓名name和年龄age。定义构造方法用来初始化数据成员。再定义显示display方法将姓名和年龄打印出来。 在main方法中创建人类的实例然后将信息显示。

 
public class lianxi
{
    private String name;
    private int age;
    public lianxi(String name,int age)
    {
    this.name=name;
    this.age=age;
    }
    public void display()
    {
    System.out.println("name:"+name+"\tage:"+age);
    }
    public static void main(String[] dsa)
    {
    lianxi lian=new lianxi("wing",29);
    lian.display();
    }
}

【练习题】06.get方法和set方法 定义一个类该类有一个私有成员变量通过构造方法将其进行赋初值并提供该成员的getXXX()和setXXX()方法 提示假设有private String name;则有

 
public void setName(String name){  this.name = name; }  public String getName(){  return this.name; }  
 
public class lianxi
{
    private int i;
    public lianxi(int i)
    {
        lianxi lian=new lianxi();
    lian.seti(i);
    lian.geti();
    System.out.println("i="+i);
    }
    public lianxi()
    {}
    public int geti()
    {
    return i;
    }
    public void seti(int i)
    {
    this.i=i;
    }
    public static void main(String[] dsa)
    {
    lianxi lian=new lianxi(3);
    }
}

【练习题】07.构造方法与重载 为“无名的粉”写一个类class WuMingFen 要求： 1.有三个属性 面码:String theMa 粉的分量(两) int quantity 是否带汤 boolean likeSoup 2.写一个构造方法 以便于简化初始化过程 如 WuMingFen f1 = new WuMingFen("牛肉",3,true); 3.重载构造方法 使得初始化过程可以多样化 WuMingFen f2 = new WuMingFen("牛肉",2); 4.如何使得下列语句构造出来的粉对象是酸辣面码、2两、带汤的 WuMingFen f3 = new WuMingFen(); 5.写一个普通方法 check() 用于查看粉是否符合要求。即 将对象的三个属性打印在控制台上。

 
public class WuMingFen 
{
    private String theMa;
    private int quantity;
    private boolean likeSoup;
    public WuMingFen (String s,int i,boolean b)
    {
    this.theMa=s;
    this.quantity=i;
    this.likeSoup=b;
    }
    public WuMingFen (String s,int i)
    {
    this.theMa=s;
    this.quantity=i;
    }
    public WuMingFen (String s,boolean b,int i)
    {
    this.theMa=s;
    this.quantity=i;
    this.likeSoup=b;
    if (b==true)
    {
        String b1="带汤的";
        System.out.println(theMa+quantity+"两"+b1);
    }
    }
    public void check()
    {
        if (likeSoup==true)
    {
        String b1="带汤的";
        System.out.println("面码："+theMa+"\n分量"+quantity+"\n"+b1);
    }
    else
        {
        String b1="不带汤的";
        System.out.println("面码："+theMa+"\n分量"+quantity+"\n"+b1);
    }
    }
    public static void main(String[] args)
    {
    WuMingFen lian=new WuMingFen ("沙茶面",2,true);
    lian.check();
    }
}

【练习题】08.构造方法的重载 定义一个名为Vehicles 交通工具 的基类 该类中应包含String类型的成员属性brand 商标 和color 颜色 还应包含成员方法run 行驶 在控制台显示“我已经开动了” 和showInfo 显示信息 在控制台显示商标和颜色 并编写构造方法初始化其成员属性。 编写Car 小汽车 类继承于Vehicles类 增加int型成员属性seats 座位 还应增加成员方法showCar 在控制台显示小汽车的信息 并编写构造方法。 编写Truck 卡车 类继承于Vehicles类 增加float型成员属性load 载重 还应增加成员方法showTruck 在控制台显示卡车的信息 并编写构造方法。 在main方法中测试以上各类。

 
public class Vehicles 
{
    public String brand;
    public String color;
    public void run()
    {
    System.out.println("i am running");
    }
    public Vehicles(String b, String b1)
    {
    this.brand=b;
    this.color=b1;
    }
    public void showInfo()
    {
    System.out.println("brand:"+this.brand+"\tcolor:"+this.color);
    }
    public static void main(String[] dad)
    {
    Vehicles lian=new Vehicles ("Lamborgihini","yellow");
    lian.showInfo();
    car c=new car("Aventador","green",6);
    c.showCar();
    Truck t=new Truck("Dongfangxuetielong","Bule",12);
    t.showTruck();
    }
}
class car extends Vehicles 
{
    public int seat;
    public void showCar()
    {
    System.out.println("i am a "+this.brand+"my color is "+this.color+"i have "+this.seat+"seats~");
    }
    public car(String b, String b1,int s)
    {
    super(b,b1);
    this.seat=s;
    }
}
class Truck extends Vehicles 
{
    public float load;
    public void showTruck()
    {
    System.out.println("i am a "+this.brand+"my color is "+this.color+"i can stand "
                                                +this.load+"tons of materials");
    }
    public Truck(String b, String b1,float f)
    {
    super(b,b1);
    this.load=f;
    }
}

【练习题】09.构造方法与重载 定义一个网络用户类 要处理的信息有用户ID、用户密码、email地址。在建立类的实例时 把以上三个信息都作为构造函数的参数输入 其中用户ID和用户密码时必须的 缺省的email地址是用户ID加上字符串"@gameschool.com"

 
public class UerInfo
{
    private int id;
    private String pwd;
    private String e_add;
    public UerInfo(int i,String s,String s1)
    {
    this.id=i;
    this.pwd=s;
    this.e_add=s1;
    System.out.println(id+"\n"+pwd+"\n"+e_add);
    }
    public UerInfo(int i,String s)
    {
    this.id=i;
    this.pwd=s;
    this.e_add=id+"@gameschool.com";
    System.out.println(id+"\n"+pwd+"\n"+e_add);
    }
    public static void main(String[] dsa)
    {
    UerInfo uer=new UerInfo(1201012204,"dwajldwajlj","1111111111@gameschool.com");
    UerInfo u=new UerInfo(1201012204,"dwijadiwjal");
    }
}

【练习题】10.构造方法与重载、包 编写Addition类 该类中应包含一组实现两数相加运算的重载方法。 实现加法运算的方法 应接受两个参数 即加数和被加数 方法将两个参数进行加法运算后 返回相加结果。考虑可能针对不同的数据类型进行计算 重载一组方法 包括整型、长整型、浮点型、双精度浮点型、还有字符串。 在main方法中创建Addition类的实例 分别调用重载方法测试其效果。 应将Addition类打入到包中 以自己名字的拼音为包命名。

 
package cj.lian;
public class lianxi
{
    public void additionInt(int x,int y)
    {
    int sum=x+y;
    System.out.println("sum="+sum);
    }
    public void additionLong(long x,long y)
    {
    long sum=x+y;
    System.out.println("sum="+sum);
    }
    public void additionFloat(float x,float y)
    {
    float sum=x+y;
    System.out.println("sum="+sum);
    }
    public void additionDouble(double x,double y)
    {
    double sum=x+y;
    System.out.println("sum="+sum);
    }
    public void additionString(String x,String y)
    {
    String sum=x+y;
    System.out.println("sum="+sum);
    }
    public static void main(String[] dsa)
    {
        lianxi lian=new lianxi();
        lian.additionInt(1,2);
        lian.additionString("1","2");
    }
}

【练习题】11.构造方法与重载 将上次练习题三中编写的MyTime类打到以自己名字的拼音命名的包中 并为该类重载一组构造方法 以方便使用者能够以多种形式初始化该类的实例。

 
package java.time;
public class MyTime
{
   private int hour;
   private int minute;
   private int second;
   public MyTime(int x,int y,int z)
   {
   this.hour=x;
   this.minute=y;
   this.second=z;
   }
   public MyTime()
   {}
   public void display()
   {
   System.out.println("the time is "+this.hour+":"+this.minute+":"+this.second);
   }
   public void addHour(int hou)
   {
   this.hour=this.hour+hou;
   }
   public void addSecond(int sec)
   {
   this.second=this.second+sec;
   }
   public void addMinute(int min)
   {
   this.minute=this.minute+min;
   }
   public void subHour(int hou)
   {
   this.hour=this.hour-hou;
   }
   public void subMinute(int min)
   {
   this.minute=this.minute-min;
   }
   public void subSecond(int sec)
   {
   this.second=this.second-sec;
   }
   public static void main(String[] das)
   {
   MyTime t=new MyTime();
   t.display();
   }
}

编译包： javac -d . MyTime.java

【练习题】12.构造方法与重载 建立一个汽车类 包括轮胎个数 汽车颜色 车身重量等属性。并通过不同的构造方法创建事例。 至少要求 汽车能够加速 减速 停车。 要求 命名规范 代码体现层次 有友好的操作提示。

 
public class car
{
    private int lunzi;
    private String color;
    private double weight;
    public car(){}
    public car(int i,String s,double d)
    {
    this.lunzi=i;
    this.color=s;
    this.weight=d;
    }
    public void SpeedUp()
    {
    System.out.println("i am speeding up~");
    }
    public void SpeedDown()
    {
    System.out.println("i am speeding down~");
    }
    public void Stop()
    {
    System.out.println("i have stopped");
    }
    public static void main(String[] das)
    {
    car c=new car();
    car c1=new car(4,"yellow",1.45);
    c.SpeedUp();
    c.SpeedDown();
    c.Stop();
    }
}

【练习题】13.构造方法与重载 创建一个类 为该类定义三个构造函数 分别执行下列操作 1、传递两个整数值并找出其中较大的一个值 2、传递三个double值并求出其乘积 3、传递两个字符串值并检查其是否相同 4、在main方法中测试构造函数的调用

 
public class lianxi
{
    public lianxi(int x,int y)
    {
    if (x>y)
    {
        System.out.println("The max is "+x);
    }
    else
        System.out.println("The max is "+y);
    }
    public lianxi(double d1,double d2,double d3)
    {
    double ji=d1*d2*d3;
    System.out.println("The multiply result is "+ji);
    }
    public lianxi(String s1,String s2)
    {
    boolean b;
    if (s1.equals(s2))
    {
        b=true;
        System.out.println(b);
    }
    else
    {
        b=false;
        System.out.println(b);
    }
    }
    public static void main(String[] dasd)
    {
    lianxi c=new lianxi(1,2);
    lianxi c1=new lianxi(1,2,3);
    lianxi c2=new lianxi("nihao","nihao");
    }
}

【练习题】14.Static关键字与普通变量的区别 创建一个名称为StaticDemo的类 并声明一个静态变量和一个普通变量。对变量分别赋予10和5的初始值。在main()方法中输出变量值。

 
public class StaticDemo
{
    private static int i=10;
    private int y=5;
    public static void main(String[] das)
    {
    StaticDemo s=new StaticDemo();
    System.out.println("The static digit is "+car.i+"\n and the normal digit is "+s.y);
    }
}

【练习题】15.继承 创建一个名称为MainPackage的包 使它包含MainClass和MainSubClass类。MainClass类应当包含变量声明 其值从构造函数中输出。MainSubClass类从MainClass派生而来。试执行下列操作 创建一个名称为SamePackage的类 使它导入上述包 并创建一个MainSubClass类的对象。

创建MainClass包--

 
package MainPackage.Main;
public class MainClass
{
public int i=10;
public MainClass()
{
 System.out.println(i);
 }
}

创建MainSubClass包--

 
package MainPackage.Main;
public class MainSubClass extends MainClass
{
 public MainSubClass (){}
}

创建SamePackage类---

 
import  MainPackage.Main.MainSubClass;
public class SamePackage 
{
    public static void main(String[] da)
    {
    MainSubClass m=new MainSubClass();
    }
}

【练习题】16.包、继承、构造函数 创建一个名称为MainPackage的包 使它包含MainClass和MainSubClass类。MainClass类应当包含变量声明 其值从构造方法中输出。MainSubClass类从MainClass派生而来。试执行下列操作 创建一个名称为SamePackage的类 使它导入上述包 并创建一个MainSubClass类的对象。

创建MainClass包--

 
package MainPackage.Main;
public class MainClass
{
public int i=10;
public MainClass()
{
 System.out.println(i);
 }
}

创建MainSubClass包--

 
package MainPackage.Main;
public class MainSubClass extends MainClass
{
 public MainSubClass (){}
}

创建SamePackage类---

 
import  MainPackage.Main.MainSubClass;
public class SamePackage 
{
    public static void main(String[] da)
    {
    MainSubClass m=new MainSubClass();
    }
}

【练习题】17.继承 创建一个父类和子类 父类有一个数据成员 子类继承父类的该数据成员 通过构造函数初始化并显示该数据成员的值。

 
 class Father
{
    public int i=10;
}
class Son extends Father
{
    public lianxi()
    {
    System.out.println(i);
    }
    public static void main(String[] dsa)
    {
    Son s=new Son ();
    }
}

【练习题】18.覆盖、继承 建立一个汽车Auto类 包括轮胎个数 汽车颜色 车身重量、速度等成员变量。并通过不同的构造方法创建实例。至少要求 汽车能够加速 减速 停车。 再定义一个小汽车类Car 继承Auto 并添加空调、CD等成员变量 覆盖加速 减速的方法

 
public class Auto
{
    public int luntai;
    public String color;
    public double weight;
    public int speed;
    public Auto(){}
    public void jiasu()
    {
    System.out.println("wo zai jiasu");
    }
    public void jiansu()
    {
    System.out.println("wo zai jiansu");
    }
    public void tingzhi()
    {
        System.out.println("wo bu kai le ");
    }
    public static void main(String[] dsa)
    {
    car c=new car();
    c.jiasu();
    c.jiansu();
    }
}
class car extends Auto
{
    public String air_condition;
    public String cd;
    public void jiasu()
    {
    System.out.println("wo shi jiaoche, wo zai jiasu");
    }
    public void jiansu()
    {
    System.out.println("wo shi jianche,wo zai jiansu");
    }
}
```java
【练习题】19.抽象类与继承 设计一个能细分为矩形、三角形、圆形和椭圆形的“图形”类。
使用继承将这些图形分类 找出能作为基类部分的共同特征(如校准点)和方法(如画法、初始化) 
并看看这些图形是否能进一步划分为子类。 本题只考虑实现思想 不考虑具体实现的细节 实现方式可自由发挥。
```java
abstract class tuxing
{
    public tuxing()
    {
    System.out.println("i am tuxing");
    }
    public static void main(String[] dsa)
    {
    juxing j=new juxing();
    circle c=new circle();
    tuoyuan t=new tuoyuan();
    }
}
class juxing extends tuxing
{
    public juxing()
    {
    System.out.println(" i am juxing");
    }
}
class circle extends tuxing
{
    public circle()
    {
    System.out.println("i am circle");
    }
}
class tuoyuan extends circle
{
    public tuoyuan()
    {
    System.out.println("i am tuoyuan");
    }
}

【练习题】20.抽象类 创建一个Vehicle类并将它声明为抽象类。在Vehicle类中声明一个NoOfWheels方法 使它返回一个字符串值。创建两个类Car和Motorbike从Vehicle类继承 并在这两个类中实现NoOfWheels方法。在Car类中 应当显示“四轮车”信息 而在Motorbike类中 应当显示“双轮车”信息。创建另一个带main方法的类 在该类中创建Car和Motorbike的实例 并在控制台中显示消息。

 
public class lianxi
{
    public static void main(String[] dsa)
    {
    Car c=new Car();
    c.NoOfWheels();
    Motorbike m=new Motorbike();
    m.NoOfWheels();
    }
}
abstract class Vehicle
{
    public void NoOfWheels(){}
}
class Car extends Vehicle
{
    public void NoOfWheels()
    {
    System.out.println("四轮车");
    }
}
class Motorbike extends Vehicle
{
    public void NoOfWheels()
    {
    System.out.println("双轮车");
    }
}

【练习题】21.抽象类 创建一个Vehicle类并将它声明为抽象类。在Vehicle类中声明一个NoOfWheels方法 使它返回一个字符串值。创建两个类Car和Motorbike从Vehicle类继承 并在这两个类中实现NoOfWheels方法。在Car类中 应当显示“四轮车”信息 而在Motorbike类中 应当显示“双轮车”信息。创建另一个带main方法的类 在该类中创建Car和Motorbike的实例 并在控制台中显示消息。

 
public class lianxi
{
    public static void main(String[] dsa)
    {
    Car c=new Car();
    c.NoOfWheels();
    Motorbike m=new Motorbike();
    m.NoOfWheels();
    }
}
abstract class Vehicle
{
    public void NoOfWheels(){}
}
class Car extends Vehicle
{
    public void NoOfWheels()
    {
    System.out.println("四轮车");
    }
}
class Motorbike extends Vehicle
{
    public void NoOfWheels()
    {
    System.out.println("双轮车");
    }
}

【练习题】22.接口 创建一个名称为Vehicle的接口 在接口中添加两个带有一个参数的方法start()和stop()。在两个名称分别为Bike和Bus的类中实现Vehicle接口。创建一个名称为interfaceDemo的类 在interfaceDemo的main()方法中创建Bike和Bus对象 并访问start()和stop()方法。

 
public interface Vehicle
{
    public void start();
    public void stop();
}//借口类
public class interfaceDemo
{
    public static void main(String[] dsa)
    {
        Bike bike=new Bike();
        bike.start();
        bike.stop();
        Bus bus=new Bus();
        bus.start();
        bus.stop();
    }
}
class Bike implements Vehicle
{
    public void start()
    {
    System.out.println("i am bike, i am running");
    }
    public void stop()
    {
    System.out.println("i am bke,i am stop");
    }
}
class Bus implements Vehicle
{
    public void start()
    {
    System.out.println("i am bus, i am running");
    }
    public void stop()
    {
    System.out.println("i am bke,i am stop");
    }
}

【练习题】23.接口 创建一个名称为Vehicle的接口 在接口中添加两个带有一个参数的方法start()和stop()。在两个名称分别为Bike和Bus的类中实现Vehicle接口。创建一个名称为interfaceDemo的类 在interfaceDemo的main()方法中创建Bike和Bus对象 并访问start()和stop()方法。

 
public interface Vehicle
{
    public void start();
    public void stop();
}//借口类
public class interfaceDemo
{
    public static void main(String[] dsa)
    {
        Bike bike=new Bike();
        bike.start();
        bike.stop();
        Bus bus=new Bus();
        bus.start();
        bus.stop();
    }
}
class Bike implements Vehicle
{
    public void start()
    {
    System.out.println("i am bike, i am running");
    }
    public void stop()
    {
    System.out.println("i am bke,i am stop");
    }
}
class Bus implements Vehicle
{
    public void start()
    {
    System.out.println("i am bus, i am running");
    }
    public void stop()
    {
    System.out.println("i am bke,i am stop");
    }
}

【练习题】24.抽象类、继承、接口综合 设计一个系统 XXX门的实现过程 流程 设计一张抽象的门Door 那么对于这张门来说 就应该拥有所有门的共性 开门openDoor()和关门closeDoor() 然后对门进行另外的功能设计,防盗--theftproof()、防水--waterproof()、防弹--bulletproof()、防火、防锈…… 要求 利用继承、抽象类、接口的知识设计该门
接口 Imen

 
public interface Imen
{
    public void threfproof();
    public void waterproof();
    public void fireproof();
    public void bulletproof();
    public void rustproof();
}
public class lianxi
{
    public static void main(String[] args)
    {
    men m=new men();
    m.opendoor();
    m.closedoor();
    }
}
abstract class Door
{
    public void opendoor(){};
    public void closedoor(){};
}
class men extends Door implements Imen
{
    public void opendoor()
    {
    System.out.println("i can open the door");
    }
    public void closedoor()
    {
    System.out.println("i can close the door");
    }
    public void threfproof()
    {
    System.out.println("i can threfproof");
    }
    public void waterproof()
    {
    System.out.println("i can waterproof");
    }
    public void fireproof()
    {
    System.out.println("i can fireproof");
    }
    public void bulletproof()
    {
    System.out.println("i can bulletproof");
    }
    public void rustproof()
    {
    System.out.println("i can rustproof");
    }
    
}

【练习题】25.抽象类、继承、接口综合 设计一个系统 xxx纯净水生产线 目前流程是 从某个地方把水取出来 然后经过缓冲 过滤 加热和放糖的步骤 abstract 水{ public void 水(); } interface 过滤{} interface 缓冲{} interface 加热{} interface 放糖{} class 纯净水1 extends 水 imps 过滤,缓冲{} class 纯净水2 extends 水 imps 缓冲{} class 纯净水2 extends 水 imps 过滤{} 。。。。

（重复上题的方法）

【练习题】26.综合题 定义一个抽象的"Role"类 有姓名 年龄 性别等成员变量 1. 要求尽可能隐藏所有变量(能够私有就私有,能够保护就不要公有) 再通过GetXXX()和SetXXX()方法对各变量进行读写。具有一个抽象的play()方法 该方法不返回任何值 同时至少定义两个构造方法。Role类中要体现出this的几种用法。 2. 从Role类派生出一个"Employee"类 该类具有Role类的所有成员 构造方法除外 并扩展 salary成员变量 同时增加一个静态成员变量“职工编号 ID ”。同样要有至少两个构造方法 要体现出this和super的几种用法 还要求覆盖play()方法 并提供一个final sing()方法。 3. "Manager"类继承"Employee"类 有一个final成员变量"vehicle" 4. 在main()方法中制造Manager和Employee对象,并测试这些对象的方法

 
abstract class Role1
{
    protected String name;
    protected int age;
    protected String sex;
    public abstract void play();
    public Role1(){}
    public Role1(String s,int i,String s1)
    {
    this.name=s;
    this.age=i;
    this.sex=s1;
    }
    public static void main(String[] dsa)
    {
    Employee e=new Employee();
    e.id=1201012204;
    e.salary=15000;
    e.name="you xiao";
    e.age=20;
    e.sex="Man";
    e.play();
    e.sing();
    Manager m=new Manager();
    System.out.println(e.id);
    System.out.println(e.salary);
    System.out.println(e.name);
    System.out.println(e.age);
    System.out.println(e.sex);
    System.out.println(m.vehicle);
    }
}
class Employee extends Role1
{
    protected int id;
    protected int salary;
    public Employee(){}
    public Employee(String s,int i,String s1,int id,int salary)
    {
    super(s,i,s1);
    this.id=id;
    this.salary=salary;
    }
    public void play()
    {
    System.out.println("i can paly");
    }
    public final void sing()
    {
    System.out.println("i can sing");
    }
}
class Manager extends Employee
{
    protected final String vehicle="Lamborghini";
}

【练习题】27.综合题 题目 品尝饮料 时间 2006-06-18 一、 语言和环境 1. 实现语言 Java

1. 环境要求 JDK1.4或以上版本及其联机帮助文档
   二、 要求 1、使用命令行参数 饮料类型 输出该饮料类型的味道 如 当命令行参数为1时 结果见图1 2、如果没有该种饮料 结果见如图2
   三、 推荐实现步骤
   1、建立一个Java抽象类Drink 应当 a、声明一个抽象方法taste() 该方法负责输出饮料的味道 b、声明int型常量来代表不同的饮料类型 咖啡、啤酒、牛奶 如 c、声明静态工厂方法getDrink(int drinkType) 根据传入的参数创建不同的饮料对象 并返回该对象 建议使用switch语句。该方法要求声明DrinkNotFoundException 当没有相对应的饮料类型时 抛出该异常。
   2、建立Drink的具体子类 a、分别建立Drink的子类 Coffee 代表咖啡 Beer 代表啤酒 Milk 代表牛奶 ; b、实现taste()方法 要求在控制台打印各自的味道特征。
   3、建立异常类DrinkNotFoundException a、继承Exception b、在Drink的 方 法getDrink(int drinkType)中 声 明 引 发DrinkNotFoundException异常 当传入的参数没有相对应的饮料类型时 抛出异常。 c、在使用getDrink方法的类中捕捉该异常。
   4、建立Test测试类 测试以上内容的正确性 a、编写main方法 通过命令行传参的方式传入某种饮料的类型。 b、在main方法中 调用Drink类的getDrink方法 获得相应的饮料对象。注意捕获DrinkNotFoundException。 c、然后调用该饮料对象的taste()方法 输出该饮料的味道。
   5、编译程序 并运行。
   四、 注意事项 1、仔细审题 把题目要求理解准确 2、请注意多态性的运用 3、请注意代码的书写、命名符合规范 应有适当的注释。 图2

 
import java.util.*;
abstract class Drink
{
    public abstract void taste();
    protected int i1;
    protected int i2;
    protected int i3;
    public static void getDrink(int drinkType) throws DrinkNotFoundException
    {
        if (drinkType<1||drinkType>3)
    {
        throw new DrinkNotFoundException();
    }
        switch (drinkType)
    {
    case 1:
        System.out.println("咖啡");
        break;
    case 2:
    System.out.println("啤酒");
        break;
    case 3:
    System.out.println("牛奶");
        break;
    }
    }
}
class Coffee extends Drink
{
    public void taste()
    {
    System.out.println("我是咖啡，味道是苦的");
    }
}
class Beer extends Drink
{
    public void taste()
    {
    System.out.println("我是啤酒，味道是涩的");
    }
}
class Milk extends Drink
{
    public void taste()
    {
    System.out.println("我是牛奶，味道是甜的");
    }
}
public class Role1
{
    public static void main(String[] dsa) throws DrinkNotFoundException
    {
        Coffee c=new Coffee();
    c.taste();
    Beer b=new Beer();
    c.taste();
    Milk m=new Milk();
    m.taste();
    Scanner input=new Scanner(System.in);
    System.out.println("请输入一个饮料编号:");
    try
    {
        int i=input.nextInt();
    m.getDrink(i);
    }
    catch (Exception e)
    {
        throw new DrinkNotFoundException("你输入的编号所对应的饮料不存在");
    }
    }
}
class DrinkNotFoundException extends Exception
{
    public DrinkNotFoundException()
    {
    super();
    }
    public DrinkNotFoundException(String mrg)
    {
    super(mrg);
    }
}

作者：innerClass
链接：https://www.jianshu.com/p/886252693889
來源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

1、定义长方形类，含：

  属性：宽、高（整型）；

  方法：求周长、面积；

  构造方法3个：（1）无参——宽、高默认值为1；（2）1个参数——宽、高均为参数值；（3）2个参数——宽、高各为参数值。

  要求：进行测试。

代码如下：

长方形的类：

运行结果：

 

默认长方形的周长为：4

默认长方形的面积为：1

一个参数长方形的周长为：8

一个参数长方形的面积为：4

两个参数长方形的周长为：10

两个参数长方形的面积为：6

 

2、定义圆类，它有一个变量radius(半径)。从键盘输入数据，通过构造方法传递给radius，编程计算并输出圆的周长和面积（确保输入的数据不为负数）。

  要求：进行测试。

代码如下：

圆的类：

运行结果：

正数时：

请输入圆的半径：1

圆的周长为：6.283185307179586

圆的面积为：3.141592653589793

负数时：

请输入圆的半径：-1

你输入的半径有误!

 

 

3、定义长方体类，定义求底面积、体积的方法。（可利用上述定义的长方形类）

  要求：进行测试。

 

代码如下：

长方体类：

运行结果：

长方体的底面积为:2

长方体的体积为：6

 

4、定义球类，定义求体积的方法。（可利用上述定义的圆类）

要求：进行测试。

 

 

代码如下：

球的类：

运行结果：

球的体积为：3.141592653589793

 

 

5、定义一个计算器类，包括加、减、乘、除运算。

要求：进行测试。

 

代码如下：

运行结果：

两数之和为 ：6

两数之差为：2

两数之积为：8

两数之商为：2

 

7、编写程序使用复数类Complex验证两个复数 2+2i 和3+3i 相加产生一个新的复数5+5i 。复数类Complex满足如下要求：

（1）属性：RealPart : int型，代表复数的实数部分；ImaginPart : int型，代表复数的虚数部分

（2）方法：

Complex( ) : 构造方法，将复数的实部和虚部都置0

Complex( int r , int i ) : 构造方法，形参 r 为实部的初值，i为虚部的初值。

Complex complexAdd(Complex a) : 将当前复数对象与形参复数对象相加，所得的结果仍是一个复数值，返回给此方法的调用者。

String toString( ) : 把当前复数对象的实部、虚部组合成 a+bi 的字符串形式，其中a 和 b分别为实部和虚部的数据。

（3）进行测试。

 

代码如下：

 

运行结果：

1。复数之和为：3+4i

2.复数之和为：5+7i

 

 

8、试编写Java代码实现一个计数器类Computer其中包括：

域value ：用来保存计数器的当前值；

方法increment()： 计数器加一；

方法decrement() ：计数器减一；

方法reset()：计数器清零。

请编写并调试程序。

 

代码如下：

 

运行结果：

计数器的初始值为：0

加三后的值为：3

减一后的值为：2

初始化后的值为：0