集成开发环境
讲究一站式开发，提示功能，自动纠错功能，
让软件开发更简单，更高效。
没有IDE工具，需要配置环境变量，手动将java源文件编译生成class字节码文件。
java源程序出错没有提示。
有IDE工具，不需要独立安装JDK，不需要手动配置环境变量，不需要使用javac命令对java源文件进行编译，java源文件编写语法出错后，马上提示。
不错的IDE推荐
eclipse (myeclipse) 免费 （收费）
intellij IDEA
NetBeans
JBuilder
myeclipse使用
workspace 工作区
打开后选择工作区，可以是之前的，也可以是新建工作区
选择工作区后，将来编写的java源文件，生成的class文件，都会在工作区找到，
在workspace中有一个文件夹: .metadata
在该文件存储了，当前myeclipse的工作状态
删除后，下次进入工作区，会是一个全新的开始
但是不会丢失源文件的。
面向对象封装性
面向对象三大特征： 封装 继承 多态
下面主要是封装
封装好处：
1.封装之后，看不到事物复杂的一面，只能看到简单的一面。 复杂性封装对外提供简单的操作入口。
eg： 照相机内部结构负载，但是对于使用者来说，操作非常便捷。
2. 封装之后，才会形成 真正的 独立体。
3. 封装就意味着 以后的程序可以重复使用。这个事物可以适应任何场合。
4. 封装了之后，对于事物本身提高了安全性。
package test3;
public class User {
int age;
String name;
}package test3;
/*
对于user类来说，user属性存在外部程序可以随意访问，导致age属性不安全。
*/
public class Test {
public static void main(String[] args) {
//
User user = new User();
user.age = 20;
System.out.println("用户的年龄： " + user.age);
// 修改年龄
user.age = -100;//这里age属性完全暴露给外边，导致user属性不安全。
}
}封装步骤：
1。 所有属性私有化，使用private关键字进行修饰，private表示私有的，修饰的所有的数据只能在本类中访问。
2。 对外提供简单的操作入口，以后外部程序要想访问get，必须通过这些简单入口进行访问。
修改属性值 set
获取属性值 get
3。 set 方法命名规范
public void set + 属性名首字母大写（形参）{
age = a;
}
4。 get 方法命名规范
public int getAge(){
return age;
}
setter and getter方法没有static关键字
调用 有static关键字修饰的方法 类名.方法名(实参);
调用 没有static关键字修饰的方法 引用.方法名(实参);package test3;
public class User {
private int age;
//set方法没有返回值，因为set方法只负责修改数据
public void setAge(int age){
if(age < 0 || age > 150){
System.out.println("对不起，您输入的年龄不合法！");
return;
}
this.age = age;// java就近原则
}
public int getAge(){
return age;
}
}package test3;
/*
*/
public class Test {
public static void main(String[] args) {
User user = new User();
//修改
user.setAge(100);
}
}封装例子2：
消费者
package test3;
public class Customer {
private int id;
private String name;
private int age;
private String addr;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getAddr() {
return addr;
}
public void setAddr(String addr) {
this.addr = addr;
}
}package test3;
/*
*/
public class Test {
public static void main(String[] args) {
Customer c = new Customer();
//操作入口变成了只能通过set 和 get来访问
c.setId(100);
c.setName("zs");
c.setAge(20);
c.setAddr("Beijing");
System.out.println(c.getId());
System.out.println(c.getName());
System.out.println(c.getAge());
System.out.println(c.getAddr());
}
}构造方法
java类中的构造方法：
1。构造方法 又被称为构造函数，构造器 Constructor
2。构造方法语法结构：
[修饰符列表] 构造方法名(形式参数列表){
构造方法体;
}
3。 普通方法语法结构：
[修饰符列表] 返回值类型 方法名(形式参数列表){
方法体;
}
4。 对于构造方法来说，返回值类型 不需要指定，并且也不能写void
只要写上void，那么这个方法就变成了普通方法。
构造方法名 必须 和 类名 保持一致。
5。 构造方法作用：
通过构造方法调用 可以 创建对象。
6。 构造方法应该怎么调用
new 构造方法名（实参列表）
普通方法调用：
方法修饰符有static：类名.方法名(实参列表) or
方法修饰符无static： 引用.方法名(实参列表)7。 单行注释 command + /
多行注释 command + shift + /
8。 构造方法是有返回值类型的，就是它本身，但是不能写。
9。 当一个类中没有任何构造方法的话，系统默认给该类提供一个构造方法，这个构造方法称之为 缺省构造器。
10。 当一个类 显示的将构造方法定义出来了，那么系统则不在默认为这个类提供缺省构造器。建议开发中，手动给当前类 提供 手动为打不过全部参数构造的 方法， 因为 五参数构造方法 太常用了。
package test3;
/*
*/
public class Test {
public static void main(String[] args) {
// 创建User对象
// 调用User类的构造方法完成对象的创建
// 每一个构造方法结束以后，都有一个返回值，但是这个return值不需要我们写，并且返回值的类型是构造方法所在类的类型。
// 构造方法的返回值类型 是本身，所以返回值类型不需要写。
User u = new User();
}
}11。 构造方法 支持多个方法重载机制。在一个类中编写多个构造方法。
第一个例子：
package test3;
public class User {
public User(){
System.out.println("User's Defalut Constructor ");
}
// 有参数的构造方法
public User(int i){
}
}package test3;
public class User {
public User(){
System.out.println("User's Defalut Constructor ");
}
}第二个例子：
package test3;
public class User {
public User(){
System.out.println("User's Defalut Constructor ");
}
// 有参数的构造方法
public User(int i){
System.out.println("带有int类型的构造器");
}
public User(int i, String name){
System.out.println("带有int和string类型的构造器");
}
}public class Test {
public static void main(String[] args) {
// 创建User对象
// 调用User类的构造方法完成对象的创建
// 每一个构造方法结束以后，都有一个返回值，但是这个return值不需要我们写，并且返回值的类型是构造方法所在类的类型。
// 构造方法的返回值类型 是本身，所以返回值类型不需要写。
User user = new User();
User user2 = new User(1);
User user3 = new User(1,"zs");
}
}调用方法 带static 和 不带static
总结来说，就是有static就可以直接调用，无static需要通过类new一个对象才能调用。
如果类没构造方法，那么系统默认提供一个无参数构造器。
public class Test {
public static void main(String[] args) {
//调用带static的方法
Test.doSome();
doSome();
//调用不带static的方法
// doOther在Test类当中，所以需要创建Test对象。
// 创建Test对象，调用无参数构造方法。
Test t = new Test(); //一个类当中没有任何构造方法的话，系统提供一个默认的无参数构造器。
t.doOther();
}
public static void doSome(){
System.out.println("do some!");
};
public void doOther(){
System.out.println("do other");
}
}构造方法的作用：
1。创建对象
2。创建对象的同时，初始化实例空间。 给实例变量赋值。实例变量 存储在 java内存 的 堆内存 里面。
成员变量 之 实例变量， 属于对象界别的变量，必须先有对象 才能有实例变量。
类加载 只加载了代码片段， 还未创建对象，完成初始化。
系统在默认赋值时候，在构造方法执行过程当中完成的赋值。
public class Account {
// 账号
private String actno; //实例变量，对象变量，也就是说必须先有对象才能有实例变量。
// 余额
private double balance;
// 无参数构造器
public Account(){
// 初始化实例变量的内存空间
actno = null;
balance = 0.0;
}
public Account(String s){
actno = s;
}
public Account(double d){
// actno = s;
balance = 10000;
}
public Account(String s, double d){
actno = s;
balance = d;
}
public String getActno() {
return actno;
}
public void setActno(String actno) {
this.actno = actno;
}
public double getBalance() {
return balance;
}
public void setBalance(double balance) {
this.balance = balance;
}
}public class Test {
public static void main(String[] args) {
//创造对象
Account act = new Account();
act.setActno("111");
int i = 10;
System.out.println("Account number is " + act.getActno());
System.out.println("The money in account is " + act.getBalance());
Account act2 = new Account("110");
System.out.println("Account number is " + act2.getActno());
System.out.println("The money in account is " + act2.getBalance());
Account act3 = new Account(10000.0);
System.out.println("Account number is " + act3.getActno());
System.out.println("The money in account is " + act3.getBalance());
Account act4 = new Account("act-01",1100.0);
System.out.println("Account number is " + act4.getActno());
System.out.println("The money in account is " + act4.getBalance());
}
}快捷键： shift + ctrl 可以同时选中多个目标
