java类设计
‘壹’ java程序设计
成绩我定义成double了，另外平均分我给你保留两位小数：
public class Student {
private String No; //学号
private String name; //姓名
private String gender; //性别
private int age; //年龄
private double chinese; //语文
private double math; //数学
private double english; //英语
//构造函数
public Student(String no,
String name,
String gender,
int age,
double chinese,
double math,
double english) {
No = no;
this.name = name;
this.gender = gender;
this.age = age;
this.chinese = chinese;
this.math = math;
this.english = english;
}
@Override
public String toString() {
return "Student{" +
"No='" + No + ''' +
", name='" + name + ''' +
", gender='" + gender + ''' +
", age='" + age + ''' +
", chinese=" + chinese +
", math=" + math +
", english=" + english +
'}';
}
//计算总分
public double getSum() {
return this.chinese + this.math + this.english;
}
//计算平均分
public double getAverage() {
return (this.chinese + this.math + this.english) / 3;
}
}
测试类：
class Test {
public static void main(String[] args) {
Student student = new Student(
"20190001",
"张三",
"男",
18,
109.5,
89.0,
110.0);
double sum = student.getSum();
double average = student.getAverage();
System.out.println("该学生的信息为：" + student.toString());
System.out.println("该学生的总分为：" + sum);
System.out.println("该学生的平均分为：" + String.format("%.2f", average));
}
}
运行结果：
‘贰’ java类、方法的设计
在Java面向对象编程的过程中，类的设计是一个很有挑战性的工作，不同的人可能对于类的理解不一样，设计出来的类也可能不一样，总结出以下几点关于类设计方面的建议供开发人员参考:
1.永远保持数据私有
保持数据的私有是设计类时，必须重点考虑的问题。保持私有的数据有利于封装。虽然为了保持数据的私有，需要编写设置器与访问期，但这比起不是数据私有要安全的多。
2.永远初始化数据
Java不提供对本地变量的初始化，但它会初始化对象中的实力字段。在设计类时尽量不要依赖于系统的默认值，最好明确的初始化变量。可以通过赋值或构造器对变量进行初始化。
3.不要在一个类中使用太多的基本类型
把相关的基本类型利用封装的功能，设计成一个单独的类;在引用时也同样尽量使用一个单独的类封装同一功能的类似字段。这样做的结果可以使类更易于理解和修改。
例：在一个类中需要引入人的某些属性
Private String peopleName;
Private String peopleSex;
Private String peopleBirthday;
在正中情况下，可以设计一个People类来实现这些字段的封装，在新设计的类中，只需要一个类的实例：
People aPeople = new People();
就可以得到相关的属性值。
4.尽量使类的功能单一化
这句话很难用一句明确的语言来形容，什么样的类是功能单一的呢,可以这样理解，例如设计一个类时，尽量不要将太多的功能放到一起。
‘叁’ java.按照类的设计原则进行类的设计会带来什么好处
在Java语言中， abstract class 和interface 是支持抽象类定义的两种机制。正是由于这两种机制的存在，才赋予了Java强大的 面向对象能力。abstract class和interface之间在对于抽象类定义的支持方面具有很大的相似性，甚至可以相互替换，因此很多开发者在进 行抽象类定义时对于abstract class和interface的选择显得比较随意。其实，两者之间还是有很大的区别的，对于它们的选择甚至反映出对 于问题领域本质的理解、对于设计意图的理解是否正确、合理。本文将对它们之间的区别进行一番剖析，试图给开发者提供一个在二者之间进行选择的依据。
理解抽象类
abstract class和interface在Java语言中都是用来进行抽象类(本文 中的抽象类并非从abstract class翻译而来，它表示的是一个抽象体，而abstract class为Java语言中用于定义抽象类的一种方法， 请读者注意区分)定义的，那么什么是抽象类，使用抽象类能为我们带来什么好处呢?
在 面向对象的概念中，我们知道所有的对象都是通过类来描绘的，但是反过来却不是这样。并不是 所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。抽象类往往用来表征我们在对问题领域进行分析、 设计中得出的抽象概念，是对一系列看上去不同，但是本质上相同的具体概念的抽象。比如：如果我们进行一个图形编辑软件的开发，就会发现问题领域存在着圆、 三角形这样一些具体概念，它们是不同的，但是它们又都属于形状这样一个概念，形状这个概念在问题领域是不存在的，它就是一个抽象概念。正是因为抽象的概念 在问题领域没有对应的具体概念，所以用以表征抽象概念的抽象类是不能够实例化的。
在面向对象领域，抽象类主要用来进行类型隐藏。 我们可以构造出一个固定的一组行为的抽象描 述，但是这组行为却能够有任意个可能的具体实现方式。这个抽象描述就是抽象类，而这一组任意个可能的具体实现则表现为所有可能的派生类。模块可以操作一个 抽象体。由于模块依赖于一个固定的抽象体，因此它可以是不允许修改的;同时，通过从这个抽象体派生，也可扩展此模块的行为功能。熟悉OCP的读者一定知 道，为了能够实现面向对象设计的一个最核心的原则OCP(Open-Closed Principle)，抽象类是其中的关键所在。
从语法定义层面看abstract class 和 interface
在语法层面，Java语言对于abstract class和interface给出了不同的定义方式，下面以定义一个名为Demo的抽象类为例来说明这种不同。
使用abstract class的方式定义Demo抽象类的方式如下：
abstract class Demo{
abstract void method1();
abstract void method2();
…
｝
使用interface的方式定义Demo抽象类的方式如下：
interface Demo{
void method1();
void method2();
…
}
‘肆’ Java的设计模式都有哪些
一共23种设计模式！
引用《软件秘笈-设计模式那点事》书籍：
按照目的来分，设计模式可以分为创建型模式、结构型模式和行为型模式。
创建型模式用来处理对象的创建过程；结构型模式用来处理类或者对象的组合；行为型模式用来对类或对象怎样交互和怎样分配职责进行描述。
创建型模式用来处理对象的创建过程，主要包含以下5种设计模式：
工厂方法模式（Factory Method Pattern）
抽象工厂模式（Abstract Factory Pattern）
建造者模式（Builder Pattern）
原型模式（Prototype Pattern）
单例模式（Singleton Pattern）
结构型模式用来处理类或者对象的组合，主要包含以下7种设计模式：
适配器模式（Adapter Pattern）
桥接模式（Bridge Pattern）
组合模式（Composite Pattern）
装饰者模式（Decorator Pattern）
外观模式（Facade Pattern）
享元模式（Flyweight Pattern）
代理模式（Proxy Pattern）
行为型模式用来对类或对象怎样交互和怎样分配职责进行描述，主要包含以下11种设计模式：
责任链模式（Chain of Responsibility Pattern）
命令模式（Command Pattern）
解释器模式（Interpreter Pattern）
迭代器模式（Iterator Pattern）
中介者模式（Mediator Pattern）
备忘录模式（Memento Pattern）
观察者模式（Observer Pattern）
状态模式（State Pattern）
策略模式（Strategy Pattern）
模板方法模式（Template Method Pattern）
访问者模式（Visitor Pattern）
‘伍’ Java常用的几种设计模式
下面给你介绍5种设计模式：
1.单例设计模式
所谓单例设计模式简单说就是无论程序如何运行，采用单例设计模式的类（Singleton类）永远只会有一个实例化对象产生。具体实现步骤如下：
(1) 将采用单例设计模式的类的构造方法私有化（采用private修饰）。
(2) 在其内部产生该类的实例化对象，并将其封装成private static类型。
(3) 定义一个静态方法返回该类的实例。
2.工厂设计模式
程序在接口和子类之间加入了一个过渡端，通过此过渡端可以动态取得实现了共同接口的子类实例化对象。
3.代理设计模式
指由一个代理主题来操作真实主题，真实主题执行具体的业务操作，而代理主题负责其他相关业务的处理。比如生活中的通过代理访问网络，客户通过网络代理连接网络（具体业务），由代理服务器完成用户权限和访问限制等与上网相关的其他操作（相关业务）。
4.观察者设计模式
所谓观察者模式，举个例子现在许多购房者都密切观察者房价的变化，当房价变化时，所有购房者都能观察到，以上的购房者属于观察者，这便是观察者模式。
java中可以借助Observable类和Observer接口轻松实现以上功能。当然此种模式的实现也不仅仅局限于采用这两个类。
5.适配器模式
如果一个类要实现一个具有很多抽象方法的接口，但是本身只需要实现接口中的部分方法便可以达成目的，所以此时就需要一个中间的过渡类，但此过渡类又不希望直接使用，所以将此类定义为抽象类最为合适，再让以后的子类直接继承该抽象类便可选择性的覆写所需要的方法，而此抽象类便是适配器类。
‘陆’ java里如何设计这个类
package com.;
import java.util.Date;
public class Computer {
public Key key;
public Screen screen;
public Mouse mouse;
public Date time;
public Computer(Key key, Screen screen, Mouse mouse, Date time) {
this.key = key;
this.screen = screen;
this.mouse = mouse;
this.time = time;
}
public Key getKey() {
return key;
}
public void setKey(Key key) {
this.key = key;
}
public Screen getScreen() {
return screen;
}
public void setScreen(Screen screen) {
this.screen = screen;
}
public Mouse getMouse() {
return mouse;
}
public void setMouse(Mouse mouse) {
this.mouse = mouse;
}
public Date getTime() {
return time;
}
public void setTime(Date time) {
this.time = time;
}
}
class Key {
}
class Screen {
}
class Mouse {
}
‘柒’ java设计一个人的类
importjava.util.Random;
publicclassPerson{
//姓名
privateStringname;
//性别
privateStringsex;
//年龄
privateintage;
publicStringgetName(){
returnname;
}
publicvoidsetName(Stringname){
this.name=name;
}
publicStringgetSex(){
returnsex;
}
publicvoidsetSex(Stringsex){
this.sex=sex;
}
publicintgetAge(){
returnage;
}
publicvoidsetAge(intage){
this.age=age;
}
//方法一
publicvoidfirstfunction(){
this.setName("风吹激动单达产");
this.setSex("人妖");
System.out.println("睡觉："+this.getName()+"正在睡觉。");
System.out.println("跳舞：一个"+this.getSex()+"人正在跳舞，左三圈右三圈...");
}
//方法二
publicStringsecondfunction(){
this.setName("风吹激动单达产");
Stringhua="";
Randomra=newRandom();
intaa=(int)(0+Math.random()*(2+1));
if(aa==0){
hua="玫瑰花";
}elseif(aa==1){
hua="百合花";
}elseif(aa==2){
hua="月季花";
}else{
hua="菊花";
}
returnthis.getName()+"送给潘金莲一束"+hua;
}
//方法三
@SuppressWarnings("unused")
publicvoidthirdfunction(intmoney,Stringname){
this.setName("风吹激动单达产");
if(name!=null||name!=""){
System.out.println(name+"正在打"+this.getName());
}else{
if(money<=0){
System.out.println("你是小气鬼。");
}elseif(money>0&&money<=50){
System.out.println("谢谢你！");
}elseif(money>50&&money<=10000){
System.out.println("你是个好人！");
}else{
System.out.println("你是我的救星啊！我代表八辈祖宗感谢你！做鬼都不会放过你的！");
}
}
}
//方法四
(intmoney){
Stringyan="";
switch(money){
case0:
yan="无烟";
break;
case1:
yan="无烟";
break;
case2:
yan="新石家庄烟";
break;
case5:
yan="七匹狼烟";
break;
case6:
yan="红石二代烟";
break;
case7:
yan="红塔山烟";
break;
case10:
yan="玫瑰钻烟";
break;
case15:
yan="金石烟";
break;
case23:
yan="玉溪烟";
break;
case65:
yan="中华烟";
break;
default:
yan="无烟";
break;
}
returnyan;
}
publicintfourthfunctionoushu(intoushu){
intstart=0;
if(oushu>1){
for(inti=1;i<oushu;i++){
if(i%2==0){
start++;
}
}
}
returnstart;
}
publicintfourthfunctiondanshu(intone,inttwo){
intsum=0;
if(one<two){
for(inti=one;i<two;i++){
sum=sum+i;
}
sum=sum-one;
}elseif(one>two){
for(inti=two;i<one;i++){
sum=sum+i;
}
sum=sum-two;
}else{
sum=0;
}
returnsum;
}
publicstaticvoidmain(String[]args){
Personss=newPerson();
System.out.println(ss.fourthfunctionmoney(5));
}
}
‘捌’ 关于java的类设计问题 - 如何使用接口和抽象类
我的想法是这样：
四种系统和肝脏都可以设计成类，互相之间没有继承关系。
一般来说，类A继承类B，对应于现实中的“A是B”，可以借此判断是否应该用继承。比如，钢琴是乐器，所以class Piano可以继承class Instrument。在这里，血液循环系统是肝脏吗？显然不是，所以class BloodCycle继承class Liver在概念上就是不合适的。
至于一个人只有一个肝的问题，在初始化4个系统时不要初始化肝脏就行了。类BloodCycle和类Digesting都有一个类Liver的内部成员humanLiver，不初始化，而是开放一个接口，让调用者来创建一个Liver对象然后赋给BloodCycle对象和Digesting对象。伪码：
BloodCycle bloodCycle = new BloodCycle();
Digesting digesting = new Digesting();
Liver liver = new Liver();
bloodCycle.setHumanLiver(liver);
digesting.setHumanLiver(liver);
这样所有问题都解决了。Java里所有对象变量都是指针，所以bloodCycle和digesting里的humanLiver指向的是同一个对象，即共用同一个人的肝脏，符合现实生活。
‘玖’ JAVA如何设计实体类
如果说的是对应数据库信息的实体类，……对Java来说，和普通的类一模一样。只是每个类设计者有不同的用法，比如说集合类，作为各种数据结构使用。实体类主要作为存储数据库信息使用。两者Java上有区别么？没有，只是代码不一样，用法不一样。