Java程序设计第一阶段总结

Java程序设计第一阶段总结

文章简介：

例题介绍：

第一次作业：

第一次课：

第二次作业：

第二次课：

第三次作业：

第四次课：

第五次作业：

七个设计原则：

容器：

文章简介：

本篇文章会介绍从java设计入门开始讲起。

通过一个例子来讲解。

例题介绍：

对上述雨刷问题进行编程模拟，可使用交互式菜单，完成司机对雨刷系统的控制及测试

第一次作业：

可以看到第一次作业，我只知道分几个实体类，典型的垃圾代码；

第一次课：

SRP Single Responsibility Principle（功能单一原则）每个函数单一职责

IOP

知识最小化原则/最小知原则

第一例：

雨刷控制

类，具有原则性，不可再分。不要冗杂。

任何一个类，要有两个构造方法。一个无参，一个有参。

属性。只加有用的

getter/setter必有方法。

第三类，业务操作。也要符合SRP

注意区分不同类的控制，

行为分为主动操作和被动接收。

雨刷控制中，不仅有雨刷，控制杆，刻度盘，还有隐藏Driver类。

于是，重写雨刷作业

第二次作业：

可以看到已经十分有模有样了，符合了单一职责，但仍有可以改进的地方。

比如显示输出的程序并没有剥离出来。

第二次课：

关联，依赖，聚集(聚合，组合)，泛化，实现；

聚合 耦合性最高

class B{

private A obj = null;

public void fun(){

obj.funA();

}

}

可能为关联或依赖，耦合性较低

class C{

public void funC(A obj){

obj.funA();

}

}

可能为关联或依赖，耦合性最低

但当调用次数多时，创建次数会很多，效率低下。

class D{

public void funD(){

A obj  = new A();

obj.funA();

}

}

类之间的关系，本质是发送消息

一共5种关系：

1.关联association

关系比较紧密；

本质是 调用方法；

类图中用箭头表示

2.聚集aggregation（聚合、组合两种）

整体和部分间的关系。

用菱形和箭头表示

空心聚合，聚合的组成部分与整体生存期可以不一样

实心组合，整体和部分的生存期一致；

耦合性/内聚性

3.依赖

4.继承

5.没有关系

demeter 迪米特法则：

1不要和陌生人说话

2只和直接朋友通信

3最少知识原则

MVC

model view controller

entity GUI control

三种类保持低耦合性；

为了符合MVC模式，我们做了第三次雨刷

第三次作业：

可以看到，我在原有基础上增加了单例模式。

但代码还可以改进。

第四次课：

2022-3-9

java程序设计

子类若不重写抽象类方法，子类仍是抽象类。

public abstract class Shape {

String color;

public Shape() {

}

public Shape(String color) {

this.color = color;

}

}

abstract class Circle extends Shape{

private double radius = 0;

public Circle() {

}

public Circle(String color,double radius) {

super(color);

this.radius = radius;

}

public abstract double getArea() ;

}

2022-3-9

java程序设计

泛化/继承/复用关系

关键字supper

protect的使用

protect会使子类无法访问

Java中只能单继承

C++中不限

public class A {

private int no;

private String name;

public A() {

}

public A(int no,String name) {

this.no = no;

this.name = name;

}

public int getNo() {

return no;

}

public void setNo(int no) {

this.no = no;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

}

//继承性，继承no，name;

class B extends A{//A父类(java super class超类)(C++基类)，B子类(C++派生类)

//增加电话号码

private String phoneNo;

public B() {

}

public B(String phoneNo) {

this.phoneNo = phoneNo;

}

public B(int no,String name,String phoneNo) {

super(no,name);//super代表父类的一个引用对象,可以理解为指向父类的一个指针,这个父类指的是离自己最近的一个父类

this.phoneNo = phoneNo;

this.setNo(no);//this代表本类对象的一个引用对象,可以理解为:指向对象本身的一个指针

}

}

A obja = new A();

obja.getNo(455);

B objb = new B(34,"zhangsan","01099989988");

objb.getPhoneNo();

@Override  //覆写标记

Shape shape = new Circle();

子类赋值给父类

class Ball extends Circle{

public Ball() {

}

public Ball(String color,double radius) {

super();

}

}

2022-3-14

java程序设计

多态

同一个类的对象

不同的对象，接收到同一个消息，执行不同的操作

Circle circle = new Circle("black",123);

circle.getArea();

Shape shape = new Circle("red",124);

System.out.println(shape.getArea());

shape = new Ball("black",12);

System.out.printlc(shape.getArea());

定义一个函数：

function(Shape shape){

System.out.println(shape.getArea());

}

调用函数：

function(circle);

function(ball);

以上两句，因为传入的对象不同，会执行不同的getArea()方法。

这就是多态。

circle 是Shape类，但getArea()方法在Circle中，circle属于Circle类，不属于Ball类

ball是Shape类，但getArea()方法在Ball中，ball属于ball类，不属于Circle类

所以执行结果不同

为了实现多态，circle 和 ball的定义的类使用Shape(父类)，创建对象使用Circle和Ball(子类)

尽量避免父类没有的方法而写在子类这种继承

通过几个例子学习了继承关系与多态，那我们来实现它吧。

第五次作业：

可以看到这次的代码可以实现两代雨刷的使用，可以使用多态。

至此，关于类的设计，我们才算入门。

讲完最重要的类设计，我们开始往前讲，讲简单的语法。

这里再整理一下几个设计原则

七个设计原则：

2022-3-16

java程序设计

所有原则，为开闭原则服务

原则一：单一功能原则

Single Responsibility Principle, SRP

核心思想：解耦和增强内聚性（高内聚，低耦合）

类被修改的几率很大，因此应该专注于单一的功能。如果你把多个功能放在同一个类中，功能之间就形成了关联，改变其中一个功能，有可能中止另一个功能，这时就需要新一轮的测试来避免可能出现的问题

原则二：开闭原则

Open-Closed Principle, OCP

核心思想：对扩展开放，对修改关闭

扩展开放：模块添加新功能，不改变原有的代码

修改关闭：某模块被其他模块调用，如果该模块的源代码不允许修改，则该模块修改关闭的

原则三：里氏替换原则

Liskov Substitution Principle, LSP

核心思想：任何父类出现的地方，子类都可以替代出现

原则四：依赖倒转原则

Dependence Inversion Principle, DIP

核心思想：要依赖于抽象，不要依赖于具体的实现

原则五：接口分离原则

Interface Segregation Principle, ISP

核心思想：不应该强迫客户程序依赖他们不需要使用的方法

一个接口不需要提供太多的行为，一个接口应该只提供一种对外的功能，不应该把所有的操作都封装到一个接口当中

原则六：合成复用原则

Composite Reuse Principle, CRP

核心思想：尽量使用对象组合，而不是继承来达到复用的目的

继承关系是强耦合，组合关系是低耦合

原则七：迪米特原则

Law of Demeter, LoD

又称最少知识原则

核心思想：一个对象应当对其他对象有尽可能少的了解,不和陌生人说话

降低各个对象之间的耦合，提高系统的可维护性

容器：

2022-3-23

java程序设计

StringBuffer类（变长字符串）

如果

String a = "123"

如果相连接"abc",形成"123abc"

若用

a = a+"abc"

可以成功，但a原来指向的"123"会丢失，而依然存在内存中。

a指向了新的字符串"123abc"

临时变量"abc"会在这次运算后，自动消除。

这样会导致内存占越来越多

解决方法：

StringBuffer a  = new StringBuffer();

a.append("abc");//追加

使用StringBuffer类可以避免这样的尴尬。

此类支持并发。

StringBuilder类，类似于StringBuffer。

效率略高于StringBuffer，但是线性操作，不支持并发。

关于String管理者地址的延申

String str1 = "abc"

String str2 = "abc"

此时，str1或str2是一个管理者，指向"abc"这个地址。

所以str1 == str2;

String str1 = "abc"

String str2 = "ab"+"c"

此时依然str1 == str2;

这就是java的智能之处。

关于String的测速

public class Main {

public static void main(String[] args) {

String str1 = "a";//修改这里，就可以检测这三种速度

long begin = System.currentTimeMillis();

for(int i = 0;i<10000;i++) {

str1 = str1+"b";

}

long end = System.currentTimeMillis();

System.out.print(end - begin);

}

}

2022-3-23

java程序设计

容器

java有八种基本类型：

int

long

short

char

float

double

byte

boolean

java有两种容器

Collections//框架集合

Maps

两个可以实现动态空间的类。

import java.util.ArrayList;

import java.util.LinkedList;

public class Main {

public static void main(String[] args) {

// LinkedList list = new LinkedList();

ArrayList list = new ArrayList();

list.add(23);

list.add(2.5);

list.add("abc");

list.add(new Circle(2,4));

//可以直接加一个定义的类，但会有一个wrong警告

//不建议这样用

System.out.println(list);

for(int i = 0;i<3;i++) {

System.out.println(list.get(i));

}

}

}

例LinkedeList<Integer>,这样可以限制容器中只能存Integer数据类型

<>的作业就是限制类型

这样的操作称为——

泛型：把类型做参数

搜索

复制