标签：Java String 原则 java no 程序设计 Circle public 第一阶段
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数据类型
<>的作业就是限制类型
这样的操作称为——
泛型：把类型做参数
搜索
复制
标签：Java,String,原则,java,no,程序设计,Circle,public,第一阶段 来源： https://www.cnblogs.com/oohuo/p/16095961.html
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。