Java复习Day1

单例设计模式

一、构造超级英雄类SuperHero，该类有String型常量属性name，其值固定为“谭雅”、“伊万”。要求：
a. 在程序运行期间，至多只能造出一个对象，要么是谭雅，要么是伊万。
b. 如何实现：在程序运行期间，至多只能造出两个对象，其中一个是谭雅，另一个是伊万。
a

package SchoolJob.ExampleOnly1.OneExample;

public class Superhero {
    private static  final String name1="谭雅";
    private static  final String name2="伊万";
    private Superhero(){

    }//1.构造器私有化
    public static Superhero a=new Superhero();//2.定义一个类变量来记住类的一个对象
    public static Superhero getA(String name){
        if(name.equals(name1)||name.equals(name2)) {
            System.out.println("找到名为"+name+"的英雄");
            return a;
        }
        System.out.println("未找到");
        return null;
    }//3.定义一个类方法返回对象,必须是类方法，若为实例方法的话，只能对象去访问，而构造器私有，创造不了对象，方法必须是私有的
    //而类方法访问不了实例成员（实例变量，实例方法），用不了this关键字，所以上面定义的是类变量而非实例变量
 class Test {
    public static void main(String[] args) {
        //Superhero hero1=new Superhero();//由于构造器私有，无法新建对象
        Superhero hero1=Superhero.getA("找只及");
        Superhero hero2=Superhero.getA("谭雅");
        Superhero hero3=Superhero.getA("伊万");
        System.out.println(hero2);
        System.out.println(hero3);
        System.out.println(hero2==hero3);//true,说明地址一样，说明拿到的都是同一个对象
    }
}
}

package SchoolJob.ExampleOnly1.Twoexample;

public class Superhero {
    private static  final String name1="谭雅";
    private static  final String name2="伊万";
    private Superhero(){

    }//1.构造器私有化
    public static Superhero a=new Superhero();//2.定义一个类变量来记住类的一个对象
    public static Superhero b=new Superhero();
    public static Superhero getHero(String name){
        if(name.equals(name1)&&!name.equals(name2)) {
            System.out.println("找到名为"+name+"的英雄");
            return a;
        }
        else if(name.equals(name2)&&!name.equals(name1)) {
            System.out.println("找到名为"+name+"的英雄");
            return b;
        }
        System.out.println("未找到或已经存在该英雄");
        return null;
    }//3.定义一个类方法返回对象
}
class Test {
    public static void main(String[] args) {
        //Superhero hero1=new Superhero();//由于构造器私有，无法新建对象
        Superhero hero1= Superhero.getHero("找只及");
        Superhero hero2= Superhero.getHero("谭雅");
        Superhero hero3= Superhero.getHero("伊万");
        System.out.println(hero2);
        System.out.println(hero3);
        System.out.println(hero2==hero3);//false,说明地址不一样
    }
}

二、最多创建四个superhero对象，并增加Boolean limit()判断

package FinalTest.FourExample;

public class Superman {
    private static int count;//int类型成员变量默认值为0，题目要求最多4个所以后面count<4（0，1，2，3）,不写等于

    private Superman(){
        count++;
    };
    //public static Superman man=new Superman();
    public static Superman getMan(){
        if(limit()==true){//limit也得用static
      //  return man;//这样只是创造了一个对象
            return new Superman();
    }else{
            return null;
        }
    }
    public static boolean limit(){//count也只能用static
        if(count<4){
            return true;
        }
        return false;
    }
}
class Test{
    public static void main(String[] args) {
        Superman man1=Superman.getMan();
        Superman man2=Superman.getMan();
        Superman man3=Superman.getMan();
        Superman man4=Superman.getMan();
        Superman man5=Superman.getMan();
        System.out.println(man1);
        System.out.println(man2);
        System.out.println(man3);
        System.out.println(man4);
        System.out.println(man5);//null
    }
}

三、创建一个 Student 类，包含 name（String 型）、age（int 型）两个私有属性。
并满足如下要求：a. 在创建对象时，name 不得为空，且 age 的取值范围为：5≤age≤25，否则将无法创建对象；b.为使类更易于维护，必须单独设计一个 boolean limit(…)函数，实现对 name 和 age 的限制检查，符合创建条件则返回真，否则返回假。c.设计该 Student 类，其中包含构造 Student 类对象的手段。

package FinalTest.CreateClass;

public class Student {
    private static String name;
    private static int age;
    public static String getName() {
        return name;
    }
    public static void setName(String name) {
        Student.name = name;
    }
    public static int getAge() {
        return age;
    }
    public static void setAge(int age) {
        Student.age = age;
    }
    private Student(String name, int age) {// 私有构造方法
        this.name=name;
        this.age = age;
    }//实例方法既可访问实例成员也可访问类成员，还可使用this关键字
    private static boolean limit() {
        return name != null && !name.isEmpty() && (age >= 5 && age <= 25);
    }
    public static Student createClass(String name, int age) { // 创建学生对象的方法
        Student student=new Student(name, age);
        if (limit()) { // 检查限制条件
            return student;
        }
        System.out.println("不合法名字或年龄: " + name + ", " + age);
        return null;
    }
}
class Test {// 测试类
    public static void main(String[] args) {
        Student std1 = Student.createClass("Alice", 21); // 合法
        if (std1 != null) {//避免空指针异常
            System.out.println("学生名字: " + std1.getName() + ", 年龄: " + std1.getAge());
        }
        Student std2 = Student.createClass("", 18); // 非法，名字为空
        if (std2 != null) {//避免空指针异常
            System.out.println("学生名字: " + std2.getName() + ", 年龄: " + std2.getAge());
        }
        Student std3 = Student.createClass("Bob", 33); // 非法，年龄超过范围
        if (std3 != null) {//避免空指针异常
            System.out.println("学生名字: " + std3.getName() + ", 年龄: " + std3.getAge());
        }
    }
}

四、

package FinalTest.creatSanJiao;


public class SanJiao {
        private static int a;
        private static int b;
        private static int c;
        private SanJiao(int x,int y,int z){
            this.a=x;
            this.b=y;
            this.c=z;
        }
        private static boolean limit(){
            if(a>0&&b>0&&c>0&&(a+b>c)&(a+c>b)&&(c+b>a)){
                return true;
            }
            return false;
        }
        public static SanJiao create(int x,int y,int z){
            SanJiao sanJiao=new SanJiao(x, y, z);
            if(limit()==true){
                System.out.println("创建了一个三边为"+x+y+z+"的三角形");
                return sanJiao;
            }
            System.out.println("无法创建");
            return null;
        }
}
class Test{
    public static void main(String[] args) {
        SanJiao sanJiao=SanJiao.create(7,8,9);
    }
}

共同点总结 1构造器私有化 2用一个类方法返回对象

掌握super,this

一、要求输出x=3 y=5,现在先给定以下代码：

public class A {
    private int x;
    public A(int x){
        this.x=x;
    }
}
public class B extends A{
    private int y;

    public static void main(String[] args) {
        new B(3,5).showInfo();
    }
}

以下是完整代码：

public class A {
    private int x;
    public A(int x){
        this.x=x;
    }

    public int getX() {
        return x;
    }
}
public class B extends A{
    private int y;

    public B(int x, int y) {
        super(x);
        this.y = y;
    }
    public void showInfo(){
        System.out.println("x="+getX()+" y="+this.y);
    }//由于B是A的子类因此可以使用父类的getX方法
    public static void main(String[] args) {

        new B(3,5).showInfo();
    }
}

二、某公司有董事长、经理等不同类型的员工，均具有私有属性：Sting 型的 name。他
们关联同一个 Data 型的数据集，但看到的视图不同。请基于抽象类，构造一组类，使
之能得到给定的输出结果。其中 App 类中的有（1）、（2）两处空需要填写。
注意：类中定义的所有属性均只能为私有权限。
class Data{;} //不必更改
abstract class 员工{ /* 需要完善 */ }
class App{
public static void view((1) s){ s.dealData(); }
public static void main (String[] args) {
Data d=new Data();
（2） [] s={new 董事长(“张三”,d),new 经理(“李四”,d),new 经理(“王五”,d)};
for(int i=0; i<s.length; i++)
view(s[i]);
}
}
输出结果为：
董事长张三的视图…
经理李四的视图…
经理王五的视图…


public abstract class YuanGong {
    /*
    抽象类和抽象方法都用abstract修饰
    抽象类不一定有抽象方法，由抽象方法的一定是抽象类
    抽象类只能由方法签名，不能有方法体
    类中具备的成员变量，方法，构造器，抽象类都具备
    抽象类，接口，构造器私有的类都不能创建对象
    一个继承抽象类的类必须重写其所有抽象方法，否则也必须定义为抽象类
     */
    private String name;
    public YuanGong(String name){
        this.name=name;
    }
    public String getName() {
        return name;
    }
    public void dealData(){
    };
}
public class JL extends YuanGong{
    private Data data;
    public JL(String name,Data d) {
        super(name);
        this.data=d;
    }

    @Override
    public void dealData() {
        System.out.println("董事长"+getName()+"的视图");
    }
}
public class Dsz extends YuanGong{
    private Data data;
    public Dsz(String name,Data d) {
        super(name);
        this.data=d;
    }

    @Override
    public void dealData() {
        System.out.println("董事长"+getName()+"的视图");
    }
}
public class App {
    public static void view(YuanGong s){
        s.dealData();
    }
    public static void main(String[] args) {
        Data d = new Data();
        YuanGong[]s={new Dsz("张三",d),new JL("李四",d),new JL("王五",d)};
        for (int i = 0; i <s.length ; i++) {
            view(s[i]);
        }
    }
}

以上是通过super将父类信息传到子类中去
三、子类修改父类信息并传递回去
给定如下电视机类 TV，请按照需求，将下列代码补充完整：
a. 设计遥控器类 Ykq，该类的对象可向电视机对象发消息，用以更改电视机频道。
b. 将 App 中的 main()补充完整，可实现既定的输出。
注：必须通过对象间的消息传递来实现，其它方式不给分。

class TV{ private int pd=1; //代表电视机的当前频道
public void setPd(int x){ //更改频道
if (x>0 && x<100) pd=x;
}
public void show(){ //显示当前频道
System.out.println(“当前：”+pd+” 频道”);
}
}
class Ykq {//遥控器类，请补充完整
/* 请补充完整，设计必须满足需求 a /
}
class App{
public static void main (String[] args) {
/ 请补充完整，设计必须满足需求 b */
输出结果为：
当前：1 频道
下面用遥控器将频道改为 5 频道
当前：5 频道

public class TV {
    private int pd=1;
    public void setPd(int x){
        if(x>0&&x<100){
            pd=x;
        }
    }
    public void show(){
        System.out.println("当前："+pd+"频道");
    }
}
public class YKQ extends TV{
    private TV t;//初始化一个父类类型
    public YKQ(TV t) {
        this.t = t;
    }
    @Override
    public void show(){
        System.out.println("下面用遥控器将频道改为5频道");
        t.setPd(5);
    }
}
public class App {
    public static void main(String[] args) {
        TV t=new TV();
        t.show();
        TV p=new YKQ(t);//体现多态思想
        p.show();
        t.show();
    }
}

几道用到接口，list的题目

一、给定以下代码：

public class Computer {
    public static void main(String[] args) {
        ZB zb=new ZB();
        WK wk=new WK();
        SK sk=new SK();
        zb.add(wk);
        zb.add(sk);
        zb.run();
    }
}

要求显示结果为：
网卡启动网卡运行网卡停止
声卡启动声卡运行声卡停止

/*
接口：
1.常量
2.抽象方法：只能有方法签名不能有函数体
 */
public interface PCI {
    void start();
    void run();
    void stop();
}
public class SK implements PCI{
    public SK() {
        super();
    }

    @Override
    public void start() {
        System.out.println("声卡启动");
    }

    @Override
    public void run() {
        System.out.println("声卡运行");
    }

    @Override
    public void stop() {
        System.out.println("声卡停止");
    }
}
public class WK implements PCI{
    public WK() {
        super();

    }

    @Override
    public void start() {
        System.out.println("网卡启动");
    }

    @Override
    public void run() {
        System.out.println("网卡运行");
    }

    @Override
    public void stop() {
        System.out.println("网卡停止");
    }
}
public class ZB {
    List<PCI>list=new ArrayList<>();
    public void add(PCI pci){
        if(list.size()<10){
            list.add(pci);
        }
    }
    public void run(){
        for (PCI pci : list) {
            pci.start();
            pci.run();
            pci.stop();
        }
    }
}
public class Computer {
    public static void main(String[] args) {
        ZB zb=new ZB();
        WK wk=new WK();
        SK sk=new SK();
        zb.add(wk);
        zb.add(sk);
        zb.run();
    }
}

二、还有道菜场与萝卜的换汤不换药就不显示代码了
三、下面是智能周长计算器的代码框架，对给定的“圆形”类对象或“矩形”类对象，
App 中的 compute()方法能够准确计算出周长。请补充完整。
注：圆形、矩形类中的属性均为私有，圆周率为私有常量 3.14
interface 形状{
double 周长();
}
class App{
public void compute( 请补充完整（2.1） ){
System.out.println(“周长=”+ 请补充完整（2.2） );
}

public interface Shape {
    double zhouchang();
}
public class Yuan implements Shape{
    private static double Pai=3.14;
    private int r;
    public static double getPai() {
        return Pai;
    }
    public static void setPai(double pai) {
        Pai = pai;
    }
    public int getR() {
        return r;
    }
    public void setR(int r) {
        this.r = r;
    }
    public Yuan(int r) {
        this.r = r;
    }
    @Override
    public double zhouchang() {
        return getR()* 2*getPai();
    }
}
public class JuXing implements Shape{
    private int a;
    private int b;
    public JuXing(int a,int b) {
        this.a = a;
        this.b=b;
    }

    public int getA() {
        return a;
    }

    public void setA(int a) {
        this.a = a;
    }

    public int getB() {
        return b;
    }

    public void setB(int b) {
        this.b = b;
    }

    @Override
    public double zhouchang() {
        return 2*(getA()+getB());
    }
}
public class App {
    public void compute(Shape shape){
        System.out.println("周长="+shape.zhouchang());
    }
    public static void main(String[] args) {
        App app=new App();
        Shape yuan=new Yuan(6);
        app.compute(yuan);
        JuXing jx=new JuXing(3,5);
        app.compute(jx);
    }
}

数组

一、静态初始化数组
int []ages=new int[]{12,24,36};//给了具体值没写长度
int []ages={12,24,36};//简化写法，右边还是new了的
double[]scores=new double[]{89.9,99.5};
//二维数组
int [][]a={{1,2,3},{4,5},{6,7,8,9}};
二、动态初始化数组（先不存入具体值）
注：不可混用

三、利用for-each循环遍历二维数组
for (int[] ints : a) {
            for (int anInt : ints) {
                System.out.print(anInt+" ");
            }
            System.out.println();
        }

四、对象在栈堆方法区中的存储示意图

javac java
.java——->.class——>送到虚拟机运行（+核心类库）

五、数组是一种引用数据类型
数据类型

基本类型：数值型；Boolean （默认值是false）
引用型 class,interface,数组,String 默认值为null

包的权限，配置

一、
假定有“P.A”、“P.B”、“P.C”三个包，并有“销售科”类。请按照需求，将下列代码
补充完整：
a. 设计“批发商”、“代理商”、“普通药店”3 个类，隶属于上述包，类体
为空。要求，从权限上看，普通药店只能看到销售价；批发商可以看到出厂价
和销售价；代理商可以看到代理价和销售价。批发商、代理商、普通药店均无
法获知成本价。
b. 请按上述需求为 “销售科” 类及相关属性配置权限。
注：1. 建包、类的导入等语句必须要写。
2. 假定本题的 4 个类位于不同的源文件。

package P.A;
public class 销售科{
 private double 成本价;
 double 出厂价;
 protectd double 代理价;
 public double 销售价;
}
package P.A;
class 批发商{;}
package P.B;
import P.A.销售科;
class 代理商 extends 销售科{;}
package P.C;
class 普通药店{;}

简答题答案背下来

1、简述结构化方法中“结构化”的含义，面向对象程序设计中“面向对象”的含义。
答：结构化：是指将问题求解看成是一组功能模块，大的功能由若干子功能模块组成，
各子模块又有一定的独立性。即功能模块的可组合、可拆解；
面向对象：是指将客观世界视为由一组对象组成，功能的发挥（或问题的解决）就是对
象之间的互操作。
2、为何说大程序开发的侧重点是可靠性、可维护性和可重用性？
答：由于大程序很难确保完全正确，核心模块可靠更受到重视；
由于维护活动涉及整个生命周期，易于维护（即可维护性），将能降低代码的修改难度，
减少错误发生的机率，故备受重视；
模块易于重用，不仅可减少开发工作量，而且重用的模块往往更可靠。
3、java 是如何跨平台的？
答：假定要实现在 A 平台编写的程序，到 B 平台运行：
a) 用针对 A 平台的 java 编译器将源码翻译成字节码；
b) B 平台必须配有针对 B 平台的 java 虚拟机。运行时，该虚拟机先将字节码翻译成
二进制，再交给硬件执行。
4.简述 IO 机制的核心思想、处理策略及其优点。
5、简单说明 java 的异常处理策略。
6、java 最初设计时，为何十分重视可靠性，并为此实施了哪些举措？
7.假定期望设计一个类 A，类中包含一个必须要拥有 public 属性的方法 f()。当不希
望其他程序员重写此方法时，请举出三种处理策略？
答：a. 给 f()方法施加 static 修饰；
b. 给 f()方法施加 final 修饰；
c. 将类 A 设定为 final 类。