java 编程思想java 编程思想java 编程思想java 编程思想java 编程思想java 编程思想java 编程思想java 编程思想java 编程思想java 编程思想java 编程思想java 编程思想java 编程思想java 编程思想java 编程思想
转载于:https://www.cnblogs.com/zgcy123456/p/6408211.html

Java编程思想
唯一不变的是变化
1）	需求总是会变的，不想干了就别改需求
2）	技术是不断演进的，不适应就要被淘汰
3）	学会包容变化
高内聚、低耦合
      在开发过程中，肯定要改代码，当改代码的时候发现好多地方要修改，或者改完这里，发现其他地方又出现了新的问题，或者你发现如果要改，就等于重写。

      这些情况都说明你的代码耦合性太高了，代码功能的内聚性太低，代码功能依赖的太多且具体。
举例：炒饭，盖浇饭，米饭炒菜
1）	代码功能要合理划分
2）	每个功能要高内聚-只干自己的事情
3）	每个功能要低耦合-尽量少依赖
4）	聚合是必要的，高聚合就不好了
面向过程与面向对象
Java面向对象基础
类
1）	代表一类具体的事物
2）	含有该事物的属性以及修改属性的行为
3）	含有该事物应有的功能行为
4）	含有该事务对其他事务的关系说明
抽象类
1）	代表一类事物的抽象说明
2）	包含这一类事物的通用属性
3）	包含这一类事物的通用功能行为
接口
1）	一种行为或者一组相关行为的抽象
2）	不关注属性，只关注行为

面向对象特征
封装
1）	将复杂的逻辑隐藏并提供简明功能按口
2）	把复杂的操作用一个简洁方法名代替，这是封装
3）	把属性和对属性的操作组合成类，这是封装·把复杂的行为抽象为简单的接口，这是封装
4）	一类相关功能服务化，并对外提供宽容接口，隐藏具体实现，这是封装
5）	合理使用封装，会把复杂问题简单化
抽象
1）	对一些事物的共性抽取，并定义这些共性的规范或默认行为
2）	对事务的抽象是类
3）	对一些类的抽象是抽象类
4）	对行为的抽象是接口
5）	对逻辑的抽象是函数
1）	抽象可以在更高的一个层次去封装，进一步简化了逻辑继承
2）	抽象是观的，不是具体的
3）	继承落实了抽象，确定了类与抽象类、接口之间的关系
4）	减少了代码重复性，增加了代码的复用性
5）	合理使用封装、抽象与继承可以使功能内聚性更高，耦合性更低多态
心得体会
1）	抽象的继承是多样化的
2）	方法的重载是多态
3）	抽象类的多种继承是多态
4）	接口的多种实现是多态
5）	一个类实现多种接口是多态
6）	多态是java程序扩展的关键
7）	当程序是多态性的，在一定规范内这个程序是可扩展的
如何使程序是多态性的？
1）	基于抽象编程，根据需求指定抽象实现，当实现不符合需求，可重新指定新的抽象实现。
2）	在具体程序中使用父类变量引用子类对象，根据父类接口编程，根据需求动态定子类对象。

Java编程原则
开闭原则
1）	对扩展开发，对修改关闭（尽量扩展，减少修改）
2）	高内聚，低糯合
里氏代换原则
      子类必须能完全替代父类,一个基于父类的程序，切换任意子类程序都能正常运行·如果一个子类不能完全替代父类，那么多态是不可用的·子类可以扩展父类的功能，但不能改变父类原有的功能。

猫科动物肯定要长的像猫

1）	子类可以实现父类的抽象方法，但不能覆盖父类的非抽象方法
2）	子类中可以增加自己特有的方法
3）	当子类的方法重载父类的方法时，方法的前晋条件（即方法的形参）要比父类方法的输入参数更宽松
4）	当子类的方法实现父类的抽象方法时，方法的后置条件（即方法的返回值）要比父类更严格
依赖倒置原则
1）	依赖抽象而不是具体（低耦合）
2）	根据接口编程，而不是具体实现
3）	常量提取成公共变量，程序依赖变量，这也是依赖抽象
4）	变量声明尽量是抽象类
5）	模块之间的调用是抽象的接口
接口隔离原则
1）	使用单一的接口取代复杂的接口（高内聚）
2）	接口中的方法要精简（高内聚）
3）	喷肿的接口说明需要细分为多个接口（低耦合）
最少知识原则
1）	一个类对其他类的引用越少越好（低耦合）
2）	一个类引用的类越抽象越好（对引用类的细节知道的最少）（低耦合）
3）	一个类对其他的类保持最少的了解（低耦合）
单一职责
1）	不要存在多于一个导致类变更的原因
2）	一个类只干自己该干的事情（低耦合）
3）	一个方法只干一种事情（高内聚）
4）	一个接口只代表一种角色或行为（高内聚）多用组合少用继承

波音747系列飞机是由600多万个零件组成的

具体实践
1）	尽量组合复用多中功能的抽象类、接口，而不是写一个超级类，超长继承类
2）	尽量分割复杂逻辑到不同函数，组合实现逻辑。简单明了，捉高复用
3）	善于分解

KISS原则

Keep It Simple，stupid

1）	让代码简单、清晰甚至傻瓜型的
2）	复杂的问题简单化
3）	复杂的问题一般可以拆分成多个简单清晰的小问题，然后一个一个单独解决·简单的问题如果有明显的扩展需求可以适当设计，但是不要过度设计复杂化

如何使用Java变出更好的程序
Java编程思想是在遇到具体问题的时候，自己如何思考并且解决问题，如何更优雅的解决，更好的解决问题的过程。
封装 继承  多态 抽象
Java面向对象的四大特征 面向对象设计可以让人可以更好的解决复杂问题。
面向过程和面向对象的区别在于 有没有类?
封装 面向过程->面向对象 (自治性的解决 减少耦合 )
继承 复用,扩展
多态 一种事物多种形态 具体是指类引用指向子类对象 (面向多态编程?)
抽象 一种思想 抽取的思想
六大设计原则 （高内聚 低耦合）
1）	单一职责原则 （类保持简单性）
2）	里氏替换原则 （继承只扩展，不修改）
3）	依赖倒转原则 （面向接口编程）
4）	接口隔离原则 （接口的简单性）
5）	迪米特法则 （不要越权 Controller->dao）
6）	开闭原则 (只扩展不修改)

java编程思想练习题答案
精品文档2016全新精品资料-全新公文范文-全程指导写作 –独家原创                                                 PAGE1 / NUMPAGES1 java编程思想练习题答案    第二章
练习1：public class PrimitiveTest {
}
练习2：public class HelloWorld {
}
练习3：public class ATNTest {
}
练习4：public class DataOnlyTest {
public static void main {  class DataOnly { int i; double d; boolean b; void show {System.out.println; System.out.println; } class ATypeName {} int i; double d; boolean b; void show { }  System.out.println; System.out.println; System.out.println;public static void main { public static void main {} System.out.println;  static int i; static char c;}public static void main {  System.out.println; System.out.println; ATypeName a = new ATypeName; a.i =; a.d =.71828; a.b = false;  a.show;
}}}  }  System.out.println;  DataOnly data = new DataOnly; data.i =; data.d =.71828; data.b = false; data.show;
练习5：public class DOTest{
}
练习6：public class StorageTest {
}
练习7：
class StaticTest {
} static int i =7;  public static void main { }  class DataOnly {} int i; double d; boolean b; void show { }  System.out.println; System.out.println; System.out.println;  DataOnly data = new DataOnly; data.i =34; data.d =.1234545; data.b = true; data.show;public static void main {  } class StoreStuff { } StoreStuff x = new StoreStuff; System.out.println);int storage {  } return s.length *;
class Incrementable {
}
public class ITest {
}
练习8：class StaticTest {
}
class Incrementable {
}
public class OneStaticTest {
public static void main {  System.out.println; StaticTest st1 = new StaticTest; StaticTest st= new StaticTest; System.out.println; System.out.println; Incrementable.increment; System.out.println called: “); System.out.println; System.out.println; Incrementable.increment; System.out.println; System.out.println; System.out.println; static void increment { StaticTest.i++; } static int i =7; public static v

JAVA编程思想英文参考文献和翻译
时间:2016-11-15 14:44来源:毕业论文
虽然java是基于C++基础上的，但是它更是纯粹的面向对象语
“If we spoke a different language, we would perceive a somewhat different world.”3670
Ludwig Wittgenstein (1889-1951)
Although it is based on C++, Java is more of a “pure” object-oriented language.
Both C++ and Java are hybrid languages, but in Java the designers felt that the hybridization was not as important as it was in C++. A hybrid language allows multiple programming styles; the reason C++ is hybrid is to support backward compatibility with the C language. Because C++ is a superset of the C language, it includes many of that language’s undesirable features, which can make some aspects of C++ overly complicated.
The Java language assumes that you want to do only object-oriented programming. This means that before you can begin you must shift your mindset into an object-oriented world (unless it’s already there). The benefit of this initial effort is the ability to program in a language that is simpler to learn and to use than many other OOP languages. In this chapter you’ll see the basic components of a Java program and learn that (almost) everything in Java is an object.
You manipulate objects with references
Each programming language has its own means of manipulating elements in memory. Sometimes the programmer must be constantly aware of what type of manipulation is going on. Are you manipulating the element directly, or are you dealing with some kind of indirect representation (a pointer in C or C++) that must be treated with a special syntax?
All this is simplified in Java. You treat everything as an object, using a single consistent syntax. Although you treat everything as an object, the identifier you manipulate is actually a “reference” to an object.1 You might imagine a television (the object) and a remote control (the reference). As long as you’re holding this reference, you have a connection to the television, but when someone says, “Change the channel” or “Lower the volume,” what you’re manipulating is the reference, which in turn modifies the object. If you want to move around the room and still control the television, you take the remote/reference with you, not the television.
Also, the remote control can stand on its own, with no television. That is, just because you have a reference doesn’t mean there’s necessarily an object connected to it. So if you want to hold a word or sentence, you create a String reference:
String s;
But here you’ve created only the reference, not an object. If you decided to send a message to s at this point, you’ll get an error because s isn’t actually attached to anything (there’s no television). A safer practice, then, is always to initialize a reference when you create it:
String s = "asdf";
However, this uses a special Java feature: Strings can be initialized with quoted text. Normally, you must use a more general type of initialization for objects.
You must create all the objects
When you create a reference, you want to connect it with a new object. You do so, in general, with the new operator. The keyword new says, “Make me a new one of these objects.” So in the preceding example, you can say:
String s = new String("asdf");
Not only does this mean “Make me a new String,” but it also gives information about how to make the String by supplying an initial character string.
Of course, Java comes with a plethora of ready-made types in addition to String. What’s more important is that you can create your own types. In fact, creating new types is the fundamental activity in Java programming, and it’s what you’ll be learning about in the rest of this book.
Where storage lives
It’s useful to visualize some aspects of how things are laid out while the program is running—in particular how memory is arranged. There are five different places to store data: JAVA编程思想英文参考文献和翻译:http://www.lwfree.com/fanyi/lunwen_71.html
------分隔线----------------------------