java学习之练习题

package practice;

/*
 * 建立一个图形接口,声明一个面积函数,圆形和矩形都实现这个接口,并得出这两个图形的面积
注:体现面向对象的特征,对数值进行判断,用异常处理,不合法的数值要出现“这个数值不合法的提示”,不再进行运算
*/
public class AreaDemo {
    public static void main(String[] args) {
        Circle circle = new Circle(-1);
        Rectangular rectangular = new Rectangular(4, 5);
        System.out.println(circle.getArea());
        System.out.println(rectangular.getArea());
    }
}

interface Shape{
    public  double getArea() throws Exception;  
}

class Circle implements Shape{
    final static double PI=3.14;
    private double r ; 
    public Circle(double r) {
        this.r = r ;
    }
    public double getArea() {
        try{
            if(r>0)
                return PI*r*r;
            else{
                throw new Exception("数值非法!");//抛出异常捕捉异常
            }
        }catch( Exception e){
            e.printStackTrace();
        }
        return -1;
    }   
}

class Rectangular{
    private double x ;
    private double y ;
    public Rectangular(double x, double y) {
        this.x = x ;
        this.y = y; 
    }
    public double getArea() {
        try {//如果x<0,不执行if语句会不会马上跳出try执行catch?不会。
            if(x>0 || y>0){
                return x*y;
            }else{
                throw new Exception("数值非法!");//抛出异常捕捉异常
            }
        } catch( Exception e){
            e.printStackTrace();
        }
        return -1;
    }
}
package com.example.helloworld;

public class Abstract {
    public static void main(String[] args) {
        Factory f = new Factory();
        f.show();
    }
}

/*
 * 描述
 *  狗:吼叫 
 *  狼:吼叫
 *   两个事物具备共性,向上抽去,
 *   犬科,具备吼叫功能
 * 
 * 描述一个事物,却没有足够信息,这时就将这个事物成为抽象事物 面对抽象的事物,虽然不具体,但是可以简单化 不用面对具体事物
 *
 * 特点: 1.抽象方法一定定义在抽象勒种,都需要用abstract来修饰 抽象类不能实例化,不能用new关键字创建对象
 * 只有子类覆盖了所有的抽象方法后,子类具体化,子类就可以创建对象 如果没有覆盖所有的抽象方法,那么子类还是一个抽象类
 *
 * 抽象类也是不断地向上抽取而来的,抽取了方法的声明而不确定具体的方法内容 由不同的子类来完成具体的方法的内容
 *
 *
 * 问题: 抽象类中有构造函数吗?
 *  有,抽象类的构造函数虽然不能给抽象类对象实例化,因为抽象类不能创建对象
 * 但是抽象类有子类,她的构造函数可以让自乐的对象实例化
 *
 * 抽象类和一般类的异同点? 
 * 相同:都用来面熟事物,都可以进行属性和行为的描述
 *  不同:抽象类描述事物的信息不具体。一般类描述事物的信息具体
 * 代码的不同:抽象类可以定义抽象方法,一般类不行 抽象类不可以实例化,一般类可以
 *
 * 抽象类一定是一个父类吗?
 *  是的。必须需要自雷覆盖抽象方法后,才可以实例化,使用这些方法
 *
 * 抽象类中可以不定义抽象方法吗? 可以的。仅仅是让该类不能创建对象
 *
 * 抽象关键字abstract和哪些关键字不能共存呢? 
 * final 修饰的类不能有子类 
 * abstract  类的实例化必须依靠子类 
 * private   如果抽象父类私有化,子类不能修改父类的方法,必须重写 static 静态类不能创建对象,直接通过类名调用方法,而抽象类通过类名调用方法没有意义
 */

/*
 * 需求:公司中程序员有姓名,工号,薪水,还有奖金,工作内容 对给出需求进行数据建模 分析:
 * 问题领域中:
 *  程序员
 *   属性:姓名,工号,薪水 
 *  行为:工作内容
 * 项目经理
 *  属性:姓名,工号,薪水,还有奖金 
 *  行为:工作内容
 * 
 * 两者不存在所属关系,但是有共性内容,可以向上抽取 两者的共性类型是什么?
 * 雇员
 *  雇员: 属性:姓名,工号,薪水
 *   行为:工作
 */

class Employee {
    private String name;
    private String id;
    private double salary;

    Employee(String name, String id, double salary) {
        this.name = name;
        this.id = id;
        this.salary = salary;
    }
}

// 描述程序员
class Programmer extends Employee {

    Programmer(String name, String id, double salary) {
        super(name, id, salary);
    }

    public void work() {
        System.out.println("coder");
    }
}

// 描述经理
class Manger extends Employee {
    // 特有属性 奖金
    private double bonus;

    Manger(String name, String id, double salary, double bonus) {
        super(name, id, salary);
        this.bonus = bonus;

    }

}

/*
 * 抽象类中的所有方法都是抽象的 这时,可以把抽象类用另一种形式来表示。
 * 接口 初期可以理解为 接口是特殊的 
 * 接口的特点: 
 * 1、接口不可以实例化
 * 2、需要覆盖了的接口中的所有的抽象方法的子类,才可以实例化 否则,该类还是一个抽象类 
 * 3、接口是用来被实现的 类与类之间的关系 继承关系
 * 类与接口之间的关系是实现关系 接口与接口之间是 继承关系
 * 
 * 接口的好处或者解决了什么问题? 
 * 多继承:
 * 好处:可以让子类具备更多的功能 弊端:调用的不确定性
 */

/*
 * 接口的思想:
 * 笔记本地懊恼的USB的接口
 * 1、接口的出现扩展了功能
 * 2、接口其实就是暴露出来的规则
 * 3、接口的出现降低了耦合性,解耦
 * */
//接口的出现,一方在使用接口,一方在实现接口
class Mouse{

}
interface USB{

}

class NewMouse extends Mouse implements USB{

}

// 定义接口

interface Inter1 {
    /*
     * 接口中的成员和class定义的不同之处 接口中常见的成员有两种:1、全局常量 2、抽象方法 而且都有固定的修饰符,共性:成员都是public修饰的
     */
    public static final int NUM = 4;

    public abstract void show();

    public abstract void show1();
}

interface Inter2 {
    public abstract void show();

    public abstract void show2();
}

interface Inter3 extends Inter1, Inter2 {
    void show3();
}

/*
 * 因为继承Factory具备所属的体系具备了该体系的基本功能 还想扩展一些功能,具备show2()的功能 一个类继承一个类的同时,还可以实现多个接口
 * 避免了单继承的局限性 继承是为了获取体系的基本功能,想要扩展功能可以通过实现接口来完成
 */

// 接口与接口 之间是继承关系,而且是多继承
class Factory implements Inter1, Inter2 {
    // 为了实现接口Inter1和接口Inter2,必须将抽象类中的所有方法都实现
    // @覆盖掉父类
    public void show() {
        System.out.println("123");

    }

    public void show1() {
    }

    public void show2() {
    }

}

class Worker {
    // 必须实现三个接口中的所有方法
    public void show1() {
    }

    public void show2() {
    }

    public void show3() {
    }
}

/*//DemoA和DemoB为了实现接口Inter1.必须实现Inter1下所有的方法,下面以建立空类初始化其方法来实现接口
class DemoA implements Inter1 {
    public void show1() {
        System.out.println("方法");
    }

    public void show() {
    }
}

class DemoB implements Inter1 {
    public void show1() {
        System.out.println("方法一");
    }

    public void show() {

    }
}*/

/*
 * 为了方便创建Inter1接口的子类对象 可以用一个类先把接口中的所偶遇方法都空实现,该类创建的独享没有意义,所以可以将该类抽象
 */

//没有抽象方法的抽象类
abstract class Demo implements Inter1 {
    Demo() { 

    }

    public void show() {

    }

    public void show1() {

    }
}

class DemoA extends Demo{
    public void show() {

    }
}
class DemoB extends Demo{
    public void show() {

    }
}


//抽象类与接口
//例子:
abstract class 犬{
    abstract void 吃();
    abstract void 叫();
}

/*interface 犬{
    abstract void 吃();
    abstract void 叫();
}*/

//添加一个功能。缉毒:单独描述一个缉毒功能犬

class 缉毒犬 extends 犬{
    void 吃() {}
    void 叫() {} 
}

/*class 缉毒犬 implements 犬{
    void 吃() {}
    void 叫() {} 
}
*/
//缉毒犬是犬中的一种是  is a 的关系
//犬用于描述所有功能犬的基本功能,用class定义。父类
//所以犬不适合定义成接口

class 缉毒猪{
    void 缉毒(){}
}
/*具备缉毒功能的有很多,缉毒功能需要抽取,抽取到类中,还是抽取到接口中?
都试一下。先定义成类
abstract class 缉毒{
    abstract void 缉毒();
}
不行,因为缉毒犬继承缉毒类就不能继承其他类。因为累不能多继承

定义成接口试试*/
interface 缉毒{
    abstract void 缉毒();
}

/*class 缉毒犬 extends 犬 implements 缉毒{

}*/
/*这是可行的
类用于描述的是事物的共性基本功能
接口用于定义的都是事物的额外功能

*抽象类和接口的区别?
*1、类与类之间是集成的关系  is a
*类与接口是实现关系    like a
*
*2、抽象类中可以定义抽象和非抽象方法,子类可以直接使用,或者覆盖使用
*接口中定义的都是抽象方法,必须实现才能用
*/


/*多态:多种形态
 * 重点说的是:对象的多样性
 * 
 * */

class 动物{

}
classextends 动物{

}
/*狗  x= new 狗();
动物  x = new 狗();//狗实例即是狗类型,又是动物类型。多态性
多态在程序中的体现:父类的引用或者接口的引用指向了子类的对象

多态在程序中的体现:父类的引用或者接口的引用指向了子类的对象
多态的好处:提高了代码的扩展性

多态的弊端:不能使用子类的特有方法

多态的前提:
必须有关系,继承,实现
2.通常有覆盖
*/

abstract class Animal{
    abstract void eat();
}
class Dog extends Animal{
    void eat() {        
        System.out.println(" Eat.");
    }
}
/*调用是
 Animal a= new Dog();向上转型  左边是父类型。向上转型的好处,吟唱了子类型,提高了代码的扩展性
弊端:只能使用父类中的功能,不能使用子类特有的功能,功能被限定了
如果不需要面对子类型,通过提高扩展性,或者使用弗雷德功能即可完成操作,就使用向上转型
如归想要使用子类特有的功能呢?这就需要向下转型
Dog dog=(Dog) a;//向下转型
向下转型的好处:可以使用子类型特有的功能
弊端:面对具体的子类型。向下转型有风险。容易发生ClassCastException.只要转换类型和对象类型不匹配就会发生
想要安全,必须要进行判断,判断一个对象是否匹配某一类型
需要使用一个关键字  instanceof 对象  instanceof 类型
什么时候用向下转型,需要用子类型特有方法时,但一定要判断
*/
class Cat extends Animal{
    void eat() {        
        System.out.println(" Eat.");
    }
}



package practice;

import android.R.string;

/*
在一个类中编写一个方法,这个方法搜素一个字符数组中是否存在某个字符,
如果存在,则返回这个字符在字符数组中第一次出现的位置(序号从0开始计算),
否则,则返回-1,要搜索的字符数组的字符都以参数形式传递给该方法,
如果传入的数组为null,应抛出IllegalArgumentException异常
在类的main方法中,以各种可能出现的情况测试验证该方法是否编写的正确
例如:字符不存在,字符存在,传入的数组为null等
*/
public class SearchStr {
public static void main(String[] args) {
char[] a={‘a’,’b’,’c’};
SearchDemo searchDemo=new SearchDemo(a,’a’);
System.out.println(searchDemo.search());
}
}

class SearchDemo{
private char[] str;
private char s;
SearchDemo(char[] str,char s) {
try {
if(str.length!=0){
this.str=str;
this.s=s;
}else {
throw new Exception(“数组不能为空。”);
}

    } catch (Exception e) {
        e.printStackTrace();
    }

}

public int search(){
    int ans=0;
    for(int i=0,end=str.length;i<end;i++){  
        if(s==str[i]){
            ans= i;
        }else{
            ans= -1;
        }

    }
    return ans;
}

}














展开阅读全文

没有更多推荐了,返回首页