设计模式:
程式设计是思维具体化的一种方式，是思考如何解决问题的过程，
设计模式是在解决问题的过程中，一些良好思路的经验集成
	GOF提出来的23种模式  4个人创建出来的.他们总结的(其中一个是junit测试的作者)

讲模式的4个特点:
讲特点,  比如说:单例模式 就是只有一个单例.共用一个实例
生活的例子.     地球,中国..关键是看类的定义.
好处.	
设计模式写出来.
公司那些地方用						
-------------------------------------------------------------------------------------------------------
单例模式 Singleton(
 确保一个类就只有一个单例.
特点: 私有构造器,拥有一个静态的获取实例的方法,静态的实例
解决的问题:共用一个实例
饿汉式单例(类加载的时候就加载好了),
懒汉式单例(调用的时候才去加载))
例子:国家中只有一个中国.同一个QQ不能双开. 企业商标.吉尼斯世界纪录.NBA,CBA,诺贝尔文学奖,奥运会,世界杯
jdk:    * java.lang.Runtime#getRuntime()
    * java.awt.Toolkit#getDefaultToolkit()
    * java.awt.GraphicsEnvironment#getLocalGraphicsEnvironment()
    * java.awt.Desktop#getDesktop()
项目:spring的beanFactory,数据库连接.
-------------------------------------------------------------------------------------------------------
工厂模式 Factory:
主要是为创建对象,提供过渡接口,以便将创建对象的具体过程隐藏起来.
结构: 对外提供一个方法,根据传入的对象得到不同的实例.
提高了灵活性.
 安全,可扩展性强.修改起来也方便.      
举例: 去饭店吃饭.只要点个菜就可以了.不需要知道怎么去做的.去肯德基吃东西.汽车厂造汽车.
jdk:    * java.lang.Proxy#newProxyInstance()
    * java.lang.Object#toString()
    * java.lang.Class#newInstance()
    * java.lang.reflect.Array#newInstance()
    * java.lang.reflect.Constructor#newInstance()
    * java.lang.Boolean#valueOf(String)
    * java.lang.Class#forName()
项目:从DBUtil里面得到Connection对象.
-------------------------------------------------------------------------------------------------------  
模版模式 template:
  父类定义流程.子类去具体实现
  结构:父类去定义抽象的方法,子类去实现这个方法,然后父类去调用.
好处: 
 减少重复的代码.
 防止调用出错 
举例:  就像是给你一个模具,你只需要照着做出来.不需要知道是干什么的. 
	父类像是老板.子类像是员工,项目经理把文档做出来,然后员工去实现
jdk:    * java.util.Collections#sort()
    * java.io.InputStream#skip()
    * java.io.InputStream#read()
    * java.util.AbstractList#indexOf()
项目:Dao层的实现.Service层的实现.
------------------------------------------------------------------------------------------------------- 
外观模式  Facade:
(外观模式（Facade pattern）为子系统提供了一个更高层次、更简单的接口，
从而降低了子系统的复杂度和依赖。这使得子系统更易于使用和管理。)
结构:可以将一系列复杂的类包装成一个简单的封闭接口(类)
  封装具体的实现类.外面调用的时候只能看到它们的调用类.
好处:
  1.提供复杂系统的访问接口,简化了系统接口调用.
  2.对外部程序来说,无论内部子系统如何变化都不需要更改,实现一定程度的解耦合.
举例: 去饭店吃饭.只需要和服务员说就可以了,不需要和厨师打交道.  或者通过客服买东西.  去杂货店买东西,老板会拿给你
jdk:java.lang.Class
项目: Connection,PreparedStatement,ResultSet 直接使用DButil封装起来
-------------------------------------------------------------------------------------------------------- 
适配器模式 adapter:   (组合优于继承)
 使原本不兼容,不能一起运行的类.现在可以一起运行.
  对象适配器: 通过  被适配的类 创建的实例,调用 被适配类的方法
  类适配器,    (会造成 接口污染    继承了多余的方法)
举例: 电脑的usb接口,手机的充电接口,或者听歌的接口. 如果耳机不匹配,就需要买个一个转换的东西(适配器),
电脑和内存卡.必须要读卡器. 手机的充电器.
jdk中:# java.io.InputStreamReader(InputStream)
# java.io.OutputStreamWriter(OutputStream)
项目中: Query方法,update,add,delete等数据库操作方法.
------------------------------------------------------------------------------------------------------------ 
策略模式 strategy:
定义了一系列的解决方案(算法),并将每一个解决方案(算法)封装起来.
  而且使它们还可以相互替换,
  策略模式让解决方案(算法)的变化不会影响到使用解决方案(算法)的客户.
好处:
 降低了类和类之间的耦合度,使系统更灵活,并易于扩展
举例:  (一般是有多种解决方案的)
吃饭,   可以在家里吃,饭店吃,餐馆吃,朋友家吃,学校吃,公司吃.  只要能吃饭就可以了
去某个地方.   坐车去,走路,跑步,做的士,做小轿车,   只要能达到目的就可以了.
jdk:* java.util.Comparator#compare()
interceptor,
* javax.servlet.http.HttpServlet
* javax.servlet.Filter#doFilter()
项目中:   持久层的实现, 可以选择 jdbc,hibernate,ibatis
		页面:  可以使用jsp,ext,html,struts1 tag,strust2 tag,等等.
		数据库 : 可以选择多种数据库, mysql,oracle,sqlserver
-----------------------------------------------------------------------------------------------------------		
命令模式 command:
    命令模式的关键就是把请求封装成为命令对象，然后就可以对这个对象进行一系列的处理了
	比如把对象的每一个行为封装成一个对象,实现了代码的单一职责.分工明细
好处:降低了类与类之间的耦合度.使系统更灵活,并易于扩展.	
举例:电脑上的键盘.按一下就会执行一个命令.  电视机的遥控器.     
  客户去饭店点菜. 每一个厨师都会做不同的菜.   客户只管下菜单.
  老板下命令.
 jdk:    * java.lang.Runnable
    * javax.swing.Action
项目:事务,线程的start().
-------------------------------------------------------------------------------------------------------
代理模式 proxy:
Proxy代理模式是一种结构型设计模式，主要解决的问题是：在直接访问对象时带来的问题，
:给某一对象提供代理对象,并由代理对象控制具体对象的引用. 
分为:
①静态代理
一个具体对象只能对应一个代理对象.
如果新增了一个具体对象,就要相应的添加代理对象.
需要对代码进行更改.增加了代码的复杂性,
②动态代理:

举例:明星的经纪人,老板的秘书,买电脑去找代理商,送信.和朋友打电话等
jdk:java.lang.reflect.Proxy
项目: spring的aop,
动态代理代码:
# 自己定义类,去实现代理接口       
#          
# import java.lang.reflect.InvocationHandler;          
# import java.lang.reflect.Method;          
# import java.lang.reflect.Proxy;          
# //动态代理类只能代理接口，代理类都需要实现InvocationHandler类，实现invoke方法。
该invoke方法就是调用被代理接口的所有方法时需要调用的，该invoke方法返回的值是被代理接口的一个实现类          
# public class DynamicProxy implements InvocationHandler{               
#     private Object object;           
#     //绑定关系，也就是关联到哪个接口（与具体的实现类绑定）的哪些方法将被调用时，执行invoke方法。      
#     //Proxy.newProxyInstance的第三个参数是表明这些被拦截的方法执行时需要执行哪个InvocationHandler的invoke方法      
#     public Object bindRelation(Object object){           
#         this.object = object;          
#         return Proxy.newProxyInstance(object.getClass().getClassLoader(), object.getClass().getInterfaces(),this);           
#     }           
#     //拦截关联的这个实现类的方法被调用时将被执行          
#     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {           
#         System.out.println("Welcome");          
#         Object result = method.invoke(object, args);           
#         return result;          
   }          
 }


 --------------------------------------------解释...........
 Proxy.newProxyInstance(Service.class.getClassLoader(),Service.class.getInterfaces(),ih);
 *ih,如果是在DynamicProxy里面就可以直接使用this代替.
 *解析一下上面的代码:
 *java.lang.reflet.proxy.newProxyInstance方法根据传入的
 *(接口类型*)obj.getClass().getInterfaces()动态构造出一个(代理实例返回*).
 * 这也说明为什么动态代理实现要求其所代理的对象一定
 * (*要至少实现一个接口).因这个代理类实例是在运行时从内存中动态构造出它的实现传入的所有接口.
 * 
 * public Object invoke(Object proxy,Method method,Object[] args)throws Throwable{
 * 	//oObject是传入的Class的实例.  通过cla.newInstance()得到的,而不是这个proxy
 * 	result = method.invoke(originalObject,args)
 * }
 * 
 * InvocationHandler.invoke方法将在代理类的方法被条用之前调用,
 * 通过这个方法,我们可以在被代理类方法调用的前后进行一些处理,
 * 在上述方法中,InvocationHandler.invoke方法的参数中传递了当前被调用的方法Method.
 * 被调用的方法的参数args,通过method.invoke方法调用被代理类的原始方法实现,
 * 这样就可以在被代理类的方法调用前后写入任何想要进行的操作.
 * 


 测试类:
 # public class TestDynamicProxy {          
#     public static void main(String[] args){          
#         HelloWorld helloWorld = new HelloWorldImpl();          
#         DynamicProxy dp = new DynamicProxy();          
#         //在这里绑定的是HelloWorld,也就是HelloWorld是被代理接口。所以绑定关系时，需要传递一个HelloWorld的实现类的实例化对象。          
#         HelloWorld helloWorld1 = (HelloWorld)dp.bindRelation(helloWorld);           
#         helloWorld1.print();           
#         helloWorld1.say();          
#               
#         //helloWorld2将不被拦截      
#         HelloWorld helloWorld2 = new HelloWorldImpl();      
#         helloWorld2.print();           
#         helloWorld2.say();      
#               
#     }          
# }  
动态代理与普通的代理相比较，最大的好处是接口中声明的所有方法都被转移到一个集中的方法中处理（invoke），
这样，在接口方法数量比较多的时候，我们可以进行灵活处理，而不需要像静态代理那样每一个方法进行中转。 

动态代理类只能代理接口，代理类都需要实现InvocationHandler类，实现invoke方法。
该invoke方法就是调用被代理接口的所有方法时需要调用的，该invoke方法返回的值是被代理接口的一个实现类 
-------------------------------------------------------------------------------------------------------	
责任链模式 strategy:
使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。
将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。
优点:降低了耦合、提高了灵活性
抽象处理者角色（Handler）：它定义了一个处理请求的接口。当然对于链子的不同实现，也可以在这个角色中实现后继链。
具体处理者角色（Concrete Handler）：实现抽象角色中定义的接口，并处理它所负责的请求。如果不能处理则访问它的后继者。
举例:拨打10086的电话,普通话请按1....,取款,先输入密码.....生产食品,接力棒,去医院看病等等
    做项目,首先是项目经理做文档.然后再是设计需求,然后分配给员工,再由员工去编写.测试,完成后交给客户.
jdk:    * java.util.Comparator#compare()
    * javax.servlet.http.HttpServlet
    * javax.servlet.Filter#doFilter()
项目: 过滤器,servle,拦截器	
---------------------------------------------------------------------------------------------------------
观察者模式  observer:
观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。
这个主题对象在状态上发生变化时，会通知所有观察者对象，让他们能够自动更新自己 
举例:
留校观察的学生.天气预报.日本地震了,全世界都报道了.
小时候把别人打伤了.告诉家长,然后家长去解决.
jdk:# java.util.EventListener
# javax.servlet.http.HttpSessionBindingListener
# javax.servlet.http.HttpSessionAttributeListener
项目: jsp页面的Onsubmit,onchange
--------------------------------------------------------------------------------------------------------
抽象工厂模式 AbstractFactory:
提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
生活的例子:
汽车制造厂.更换皮肤.饭店的菜谱,上面有不同类型的菜.不同类型的菜里面又有许多菜.
康师傅工厂,卖矿泉水,饮料,方便面.
jdk:* java.util.Calendar#getInstance()
* java.util.Arrays#asList()
* java.util.ResourceBundle#getBundle()
* java.sql.DriverManager#getConnection()
* java.sql.Connection#createStatement()
* java.sql.Statement#executeQuery()
项目:dom,sax解析xml文件.
-----------------------------------------------------------------------------------------------------------
状态模式 state:
: 不同的状态,不同的行为;或者说,每个状态有着相应的行为.

举例:一个人的生老病死,已婚,未婚,离婚,热恋等..人的表情喜怒哀乐.
公司倒闭,关门,经营.发展.      银行卡的正常状态,挂失,锁定.废弃.   QQ的在线,隐身,离线等.
jdk:java.util.Iterator,
项目中:一般用来if,esle if,else这些地方. 取代if,或者switch,Servlet
---------------------------------------------------------------------------------
组合模式(解决树形结构)  composite:
 定义:将对象以树形结构组织起来,以达成"部分--整体"的层次结构,使得客户端对当前对象和组
 合对象的使用具有一致性.
优点:层次结构清晰.
举例:
学校里面有校长,主任,班主任,老师,学生.
公司里面有Boss,总经理,部门经理,组长,员工.
一棵树:树根,枝干,树叶.
jdk:# java.util.Map#putAll(Map)
# java.util.List#addAll(Collection)
# java.util.Set#addAll(Collection)
项目:  定义多个观察者,在被观察者里面定义了观察者的集合,当被观察者改变的时候,通知观察者.观察者自己进行更新
	dom,sax解析xml文件.得到一个document对象

sturts2 ：代理、观察、责任、命令、模板

  db：门面、工厂、适配器、策略、单例

1.面向对象
面向过程:我应该干什么 重在过程 
面向对象: 找谁干什么  重在对象
例子:
挑选一个电脑(台式)
 1.挑一个CPU
 2.挑一个主板
 3.挑一个显卡
 4.挑一个显示器
面向对象的好处:
1.将复杂的事情简单化
2.从事务的执行者转化为指挥者
3.更贴近人的思维(懒人思维)

2.类和对象
 
Java中 最基本的单位 就是类
 类:抽象事物的描述(模板)
 对象:用类创建出来的就是对象(具体的事物)
  创建一个类 : 关键词class 类名()
学生类测试
//类名 对象名=初值
Student stu=new Student();
//使用 对象名.属性名  进行赋值和取值
stu.name="it";
stu.age=22;
//调用成员方法 对象名.方法名()
stu.eat();
//哪个对象调用该方法 打印那个对象方法 属性
stu.sayHi();
//成员方法
public void eat() {
System.out.println("吃");
//介绍一下自己的方法
public void sayHi() {
 System.out.println("姓名:"+name);

3.成员变量与局部变量的区别

1.书写位置
 成员:类中 方法外
 局部:方法中或方法上
2.内存中表现
 成员:堆内存
 局部:栈内存  
3.声明周期
 成员:随对象进入堆内存中创建 随对象销毁而销毁
 局部:随方法的调用入栈 随方法结束而销毁
4.作用域
 成员:整个类
 局部:方法中
5.初始值
 成员:默认初始值
 局部:默认没有初值 不给初值编译报错

4.引用数据类型时传参
//要什么类型 就给什么类型
public static void fun2(Person p) {
	p.name="李四";
	p.age = 24 ;
}
	public static void main(String[] args) {
	int a=100;
	fun1(a);
	System.out.println(a);
	
	Person p1=new Person();
	p1.name="王五";
	p1.age = 28 ;
	fun2(p1);
	p1.sayHi();
}
5.匿名对象
匿名对象:没有名字的对象
一般在方法传参数的时候使用
只调用一下方法(不赋值的情况下)

public static void setNameAndAge(Person p,String name,int age) {
	p.name=name;
	p.age=age;
	p.sayHi();
}
	public static void main(String[] args) {
	//创建两个person对象
	//将重复代码 抽成一个方法
	Person p1=new Person();
	p1.name ="cdd";
	p1.age=16;
	p1.sayHi();
	
	Person p2=new Person();
	setNameAndAge(p2, "cddd", 8);

	//使用匿名对象 当方法的参数
	//好处:较少代码量
	setNameAndAge(new Person(), "cc", 20);
	//匿名对象也是对象 可以赋值属性 调用成员方法
	new Person().name="c";
	new Person().age=30;
	new Person().sayHi();
	//只调用方法可以使用匿名对象
	//测试方法时可能会使用
	
	new Person().fun();


6.封装
写方法就是封装的一种
相当于隐藏代码的实现和属性
需要开放访问方式(方法) 获取 修改
好处:提高代码的复用性 提高代码的安全性

关键字(权限修饰符)
private
被private修饰的属性只能本类中访问
        //java bean规范
	//1.声明成员变量都要私有化
	//2.给每一个成员变量提供set/get方法
	//3.必须提供 无参的构造方法
	private String phoneName;
	private String color;
	//对外开放访问方式 
	//获取方法
	public String getPhoneName() {
		return phoneName;
	}
	
	//修改(设置)方法
    public void setPhoneName(String phonename) {
    	//关键字this 代表本类的对象
    	//this.成员变量  获取本类的成员变量
    	//this.成员变量="哈哈";赋值
    	//this.成员方法 调用本类的成员方法
    	//谁调用了这个方法 谁就是this
		this.phoneName=phonename;
	}
    //规范
    //获取get+成员变量名(首字母大写)
    //修改set+成员变量名(首字母大写) 没有返回值
    public String getColor() {
		return color;
	}
    public void setColor(String color) {
		this.color=color;
	}

7.构造方法  
构造方法:对 对象的成员变量进行初始化
写法:
1.没有返回值类型(连void都不写)
2.构造方法名 要与 类名 完全一致
         public static void main(String[] args) {
		//创建一个pen对象
		//构造方法 是系统帮你调的
		//只要你创建对象,系统会帮你调用构造方法
		//构造方法执行一次
		Pen p=new Pen();
		p.sayHi();
		//测试有参
		//你传参数 系统就会找你有参的构造方法调用
		Pen p1=new Pen("钢笔","绿色");
		p1.sayHi();

类中的书写顺序
1.成员变量
2.无参构造方法
3.有参构造方法
4.成员方法
5.set/get方法

普歌-逆越团队——java面向对象基础
面向对象
面向对象与面向过程
类
接口与抽象类
内部类
访问权限控制
this和super
方法
构造方法
类内方法
数据类型
基本数据类型
包装类型
字符串
StringBuilder和StringBuffer
相关问题补充
成员变量与局部变量的区别
静态变量和实例变量
图示

面向对象
面向对象与面向过程
面向过程让计算机有步骤的顺序的做一件事情，是一种过程化的叙事思维。

这里举个例子会更容易理解，比如说“开门”。面向过程的方法内定义的是开门的具体步骤实现；面向对象是首先定义一个“Door”对象，然后抽象出门的属性和操作行为，属性包括门的颜色、尺寸、开启方式、防盗功能等；门这个对象必然也包括open()和close()两个必备行为。
类
接口与抽象类

接口可以多继承接口，抽象类只能被子类继承
接口和抽象类都不能实例化，如果要实例化，抽象类的变量通过指向实现它的子类，接口通过实现它的实现类对象。
抽象类可以有构造方法，接口中不能有构造方法。
接口只能做接口声明，抽象类可以做方法声明和方法实现

抽象类的实例化
public class Son extends Father{
    public Son(int b) {
        super(b);
    }
    @Override   //子类重写抽象方法
    public void play() {
    }
}

abstract class Father {
    public Father(int b) {
        System.out.println(b);
    }
    public abstract void play();
}

public static void main(String[] args) {
       // Son s = new Son();抽象类不能直接实例化
        Father aa = new Son(123);
    }

接口中的方法定义：

接口中可以定义静态方法的，静态方法必须要有实现。且这个静态方法只         能用public修饰。
对于普通方法，修饰符为： public, abstract, default以及组合 public abstract

对接口中的属性也有一点说明：

在interface里面的变量都是public static final 的。所以你可以这样写：

 public static final int i=10;

或

int i=10;(可以省略掉一部分)

注意：在声明的时候要给变量赋予初值,不能是默认初值。

内部类
什么是内部类？

在Java中，可以将一个类的定义放在另外一个类的定义内部，这就是内部类。内部类本身就是类的一个属性，与其他属性定义方式一致。

内部类的分类










静态内部类
只能访问外部类的静态成员变量和方法


成员内部类
可以访问外部类所有的属性和方法（但是外部类要访问成员内部类的属性和方法，必须要先实例化成员内部类）


局部内部类
定义在方法或表达式内部（不能被public ，protected，private以及static修饰，可以被final修饰）


匿名内部类
当一个内部类需要继承或者实现，而且只使用一次的时候，可以考虑使用匿名内部类。调用的时候直接使用父类的无参构造，并重写父类方法


内部类的优点

内部类可以实现java的单继承局限。

public class A {
    private int num = 100;
    public void play(){
        System.out.println("Happy!");
    }
}
public class B {
    public String name = "小李";
    public void play(){
        System.out.println("Interesting！");
    }
}
public class Outer {
    class a extends A {  //C中内部类a继承A类
        public void printA(){
            play();
        }
    }
    class b extends B { //C中内部类b继承B类
        public void printB(){
            play();
        }
    }
        public void print(){
            new a().printA();//匿名实例化a类对象并调用printA方法
            new b().printB();
    }
}
public class Test {
    public static void main(String[] args) {
        Outer o = new Outer();
        o.print();
    }
}



内部类与外部类可以方便的访问彼此的私有域（包括私有方法、私有属性）。
内部类是另外一种封装，对外部的其他类隐藏。

访问权限控制
面向对象核心思想之一就是封装，只把有限的方法和成员公开给别人，如何实现封装呢？就要用到访问权限控制符


推荐：

如果不允许外部直接通过new创建对象，构造方法必须是private
工具类不允许有public或default构造方法

为什么工具类要将方法和变量设置为静态的:

因为，这些方法只是想调用一下，不需要牵扯工具类中的任何属性和变量，所以就没有必要实例化了(new)。既然不需要实例化了，那么就用静态就行了。
类非static成员变量并且与子类共享，protected
类非static成员变量如果仅在本类使用，private
类static成员变量如果仅在本类使用，private
若是static成员变量，必须考虑是否为final
类成员方法只供类内部调用，private
类成员方法只对继承类公开，那么限制为protected

this和super
共同点：

1.都是关键字，起指代作用。

2.在构造方法中必须出现在第一行。
方法
构造方法

构造方法名必须与类名相同。
构造方法没有返回值类型，即使是void也不能有。
构造方法不能被继承、不能被重写、不能直接调用。
类定义时提供了默认的无参构造方法。
构造方法可以私有

标准代码——javabean


类内方法
1.实例方法（非静态方法）

可以调用静态变量和静态方法，当从外部创建对象后，“类名.静态方法”来调用。
public class T {
    public void A(){
        System.out.println("这是非静态方法");
    }
    public static void B(T s){
        System.out.println("这是静态方法");
        s.A();
    }
    public static void main(String[] args) {
        T obj = new T();
        B(obj);//在主函数中可以直接调用静态方法
    }
}

2.静态方法（类方法）

静态方法中不能使用实例成员变量和实例方法
静态方法不能使用super和this关键字，这两个关键字指代的都是需要被创建出来的对象。

3.静态代码块

静态代码块在类加载的时候就被调用，并且只执行一次。先于构造方法执行，不能存在任何方法体内。
数据类型
基本数据类型

包装类型
在java中很多情况都需要以对象的形式操作，包装类的存在解决了基本数据类型无法做到的事情：泛型类型参数、序列化、类型转换、高频区间数据缓存。

Java的基础数据类型的包装类：Integer，Long，Double，Float，Boolean，Byte，Short，Character。
Boolean：使用静态 final 定义，就会返回静态值

Byte：缓存区 -128~127

Short：缓存区 -128~127

Character：缓存区 0~127

Long：缓存区 -128~127

Integer：缓存区 -128~127

也就是说，在这个区间中，我们不需要new一个对象，直接赋值即可使用。

public class T {
    public static void main(String[] args) {
        Long a = 127L;     //Long缓存范围是0~127
        Long b = 127L;
        System.out.println(a==b);//true
//Integer是唯一可以修改缓存范围的包装类，注意：一旦你修改了缓存上限，都存到了常量池中，加大了内存的负担）
        Integer e = 1000;    //Integer缓存范围是-128~-127
        Integer f = 1000;
        System.out.println(e == f);
    }
}

自动装箱–基本数据类型–>包装类的过程–例如：Integer i = 5；

自动拆箱–包装类–>基本数据类型的过程–例如：Int a = new Integer(5);
字符串
字符串相关类型主要有三种：String、StringBuilder、StringBuffer
String创建对象的方式：

1.直接赋值，String 对象名=“字符串”
String name1="Tom";

2.new构造方法，String 对象名=new String(“字符串”)；
String name1=new String("Tom");

new String("Tom ") 到底产生几个对象？
String对象复制操作后，除了在堆内存中创建，也会在常量池中进行缓存，如果下次缓存中已经存在，则直接返回相应引用给创建者。

也就是说准确答案是产生了一个或两个对象
StringBuilder和StringBuffer
首先要知道，StringBuffer和StringBuilder的实现内部是和String内部一样的，都是通过 char[]数组进行储存字符串的；不同的是String的char[]数组是通过final关键字修饰的是不可变的，而StringBuffer和StringBuilder的char[]数组是可变的。


相关问题补充
成员变量与局部变量的区别
1.作用域

成员变量：针对整个类有效。

局部变量：只在方法，语句体内有效。

2.存储位置

成员变量：随着对象的创建而存在，随着对象的消失而消失，存储在堆内存中。

局部变量：当方法被调用，或者语句被执行时存在，存储在栈内存中。当方法被调用完，或语句结束后，就自动释放。

3.初始化

成员变量：有默认初始化。

局部变量：没有默认初始化，使用前必须赋值。
静态变量和实例变量
1.调用方式

静态变量可以直接通过类名调用，这个变量属于类

实例变量只能通过对象名调用，这个变量属于对象

2.存储位置

静态变量随着类的加载而存在于方法区中

成员变量随着对象的建立而存在于堆内存中

3.生命周期

静态变量随着类的消失而消失

实例变量随着对象的消失而消失
图示

有不足之处欢迎大家指正，我会一直努力更新补充~

面向对象与面向过程
面向过程：procedure oriented programming  缩写 POP,分析出解决出问题的步骤,然后再一步步的实现(注重于解决的步骤)
面向对象：object oriented programming  缩写 OOP,宏观整体的设计
Java中的类
什么是类？举个例子汽车类是对所有汽车的一个概括，但汽车类看不见摸不着，为了符合我们面向对象的思维，我们必须将此实例化，将汽车类实例化为具体汽车个体。
基本的属性和方法

成员变量：对某种事物特征的描述(这个类有什么)

方法：对某种事物行为的规定(这个类能干什么)

一个类可以包含以下类型变量：

成员变量：

成员变量是定义在类中，方法体之外的变量。

成员变量可以使用Java语言中任何一种数据类型（包括基本类型和引用类型）。

在定义成员变量时可以对其初始化，如果不对其初始化，Java使用默认的值对其初始化。

成员变量在创建对象的时候会从类中复制一份到对象中。

成员变量可以被类中方法、构造方法和特定类的语句块访问。

成员变量的作用范围为整个类体。

局部变量：

在方法、构造方法或者语句块中定义的变量被称为局部变量。

局部变量可以使用Java语言中任何一种数据类型（包括基本类型和引用类型）。

局部变量在使用前必须初始化赋值。

变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。
类变量：（也叫静态变量）类变量也声明在类中，方法体之外，但必须声明为static类型

1.类的声明格式为:

[访问权限修饰符]  [修饰符] class 类名{
}
访问修饰符有两种public，default

修饰符：final,abstract

关键字class用来定义一个类
Java类名的命名规范:

类名首字母大写,见名知意,驼峰表示
2.添加成员变量
添加对象所需要的自身属性 比如:name,size,number…
3.定义类的方法
添加类的公共行为
public class test {
    String name;
    int price;
    int size;
public void start(){
    System.out.println("开始启动");
    }
}

总结下:
​      现实生活中先有对象后有类,而编程时先设计类后创建对象.
一个类可以包含以下类型方法
成员方法：成员方法是定义在类中。这种方法在创建对象的时候创建。

语法格式：

修饰符  返回值类型/void  方法名 ( 参数列表) {

方法体语句；

[return 返回值]

}

构造方法:用来创建对象的方法
构造方法名与类名相同,且没有返回值,且不需要使用void修饰。

使用 new + 构造方法 创建一个新的对象。在创建一个对象的时候，至少要调用一个构造方法。

一个类可以有多个构造方法。

每个类都有构造方法。如果没有显式地为类定义构造方法，Java编译器将会为该类提供一个默认构造方法,但是只要在一个Java类中定义了一个构造方法后，默认的无参构造方法即失效。
例： public class Car{

public Car(){ }

public Car(String name){ // 这个构造方法有一个参数：name }

}

例：创建Car类的对象

Car   car1  = new Car();

Car car2 = new Car(“宝马”)
类方法：（也叫静态方法）类方法也声明在类中，但必须声明为static类型
方法的重载
方法的重载是指一个类中可以定义有相同的名字，但参数不同的多个方法。

调用时，会根据不同的参数表选择对应的方法。

方法重载特点:1.同一个类中  2.方法名相同 3.参数不同（可以有三方面的不同）数量不同，类型不同，顺序不同。

注意：方法重载跟方法的返回值类型,访问权限没有任何关系