类对象基础概念

1.对象：某一个具体的事物、实体或事例
2.类：具有相同属性和行为的一些对象的统称或集合（类中只有定义，执行在函数中，成员变量在类中定义，可初始化，若不初始化系统默认初始化，但不能在类中写执行语句）
3.类由属性和行为标识
4.eclipse中，一个.java程序只有一个public修饰的类，该类包括main方法，称为主类
5.实体类：描述事物的类
工具类：Arrays Math System等为工具类
主类：主函数所在类，描述当前程序，主函数就是一个程序的开始
6.成员变量（实例变量 对象特有变量）每个对象都有一个该属性，其值可以不一样，属于特有属性
（1）成员变量先默认初始化->显示初始化->针对性初始化（构造函数）
成员函数（实例函数）每个对象都可调用，由于函数不可被动态变换，所以将来用this进行区分。
局部变量与成员变量的区别：
//当成员函数试图访问一个变量时，先看当前函数的内存空间中有没有该变量
若有，值为就近变量的值 ；没有，就去所指(this)的对象里面找
//重命名的情况下，如何区分局部变量和成员变量 this.
/*
//成员变量和局部变量有何区别？
存储位置
成员变量存在于堆内存中所属对象的空间里
局部变量存在于栈内存中所属函数的空间里
生命周期
成员变量随着对象的创建而存在，随着对象的销毁而消失
局部变量随着函数的进栈而存在，随着函数的弹栈而消失
初始化
成员变量有默认初始化 显式初始化 针对性初始化
局部变量只能在初始化之后被调用
访问范围
成员变量一般而言全局访问
局部变量的作用域只存在于当前函数空间

*/
public class OOPDemoB {
public static void main(String[] args) {
Demo d=new Demo();
d.setNum(10);
System.out.println(d.getNum());
Demo d2=new Demo();
d2.setNum(20);
System.out.println(d2.getNum());
}
}
class Demo{
private int num=3;
//修改当前对象中num的值
void setNum(int num){
this.num=num;
}
//获取当前对象中num的值
int getNum(){
int num=3;
return this.num;
}
}

7.类在堆中，对象是堆中创建的，成员变量会有默认初始化，int型数据默认为0，double型为0.0，string类型默认为null，boolean型默认为false，引用数据类型默认值都为null。
8.如何创建对象、调用对象的属性和行为，修改对象的属性
创建对象：在堆内存中开辟空间 划分地址
成员变量默认初始化
成员变量显式初始化
成员变量针对性初始化
将地址传递给栈中函数中的变量
setter getter 成员变量的修改器和访问器（shift+alt+s快捷键）
9.构造函数
（1）有些对象在创建时就有一些属性的赋值->构造函数
在创建对象时就想给对象的属性赋值。
（2）只要创建对象，就会调用构造函数 ，即使没有显示定义出构造函数，系统会默认调用一个无参构造函数（隐藏的），如果一旦在类中定义了构造函数，则隐藏的构造函数就失效了。
（3）特点：函数名与类名相同；没有返回值；有修饰符；有函数体与参数列表
（4）构造函数与一般函数的区别
构造函数只有在创建对象的时候调用一次，一般函数在创建对象后可多次调用
（return仅代表当前函数结束且弹栈，void表示无返回类型，但有return，一般省略）
构造函数无返回值，有return，一般省略；
构造函数可以调用一般函数，但一般函数不能调用构造函数
构造函数可以调用构造函数，但是只能向一个方向调用，不能循环调用（构造函数之间的调用并不写函数名，用this代替，且只能在第一行）
//针对性初始化-构造函数相关
/*
构造函数
1.与类名相同
2.没有返回值类型
3.是有修饰符的
4.是一个函数 参数列表 函数体

构造函数与一般函数的区别
1.
构造函数只有在创建对象的时候 调用一次
一般函数在对象创建之后 可多次调动
2.
构造函数有无返回值，无返回值 有没有return 有

3.构造函数可以调用一般函数？可以
一般函数可以调用构造函数？不行
构造函数调用构造函数？可以 只是 不能循环调用 只能一个方向

*/
public class OOPDemoC {
	public static void main(String[] args) {
		//有些对象在创建之时就有一些属性的赋值-构造函数
		//但凡创建对象 必须进行构造函数的调用
		//在没有定义任何构造函数之前 会有一个默认无参构造函数(隐藏的)
		//如果一旦在类中 定义了构造函数 则隐藏的无参构造函数失效 
		//什么时候定义构造函数 ？在创建对象的同时想给对象的属性赋值的话
		Dog d1=new Dog();
		d1.speak();
		d1.name="旺财";
		d1.age=10;
		d1.type="二哈";
		d1.speak();
		Dog d2=new Dog("小强");
		d2.speak();
		Dog d3=new Dog("小芳",10,"萨摩耶");
		d3.speak();
	}
}
class Dog{
	String name;
	int age;
	String type;
	public Dog(){
		//构造函数在调用构造函数的时候 只能在第一行！
		this(null);
		//return;
	}
	public Dog(String name){
//		this();
		this.name=name;
		//return;
	}
	public Dog(String name,int age,String type){
		this.name=name;
		this.age=age;
		this.type=type;
		init();
		//return;
	}
	private void init() {
		System.out.println();
		System.out.println();
		System.out.println();
		System.out.println();
		System.out.println();
		System.out.println();
		System.out.println();
	}
	public void speak(){
		System.out.println(name+","+age+","+type);
		//return;
	}
}

10 如何创建一个类
先分析该事物中有哪些成员变量(对象的特有属性)(private)；有哪些成员函数(private) 是否私有化；看该函数的功能是否需要向外界暴露
当我们在创建对象的时候，是否需要传值？因为无论是否传值构造函数一定会执行！如果需要，则定义相应的构造函数
那么此时是否还需要setter getter?
如果之后的成员变量的值需要修改的话需要setter
一般而言 最好写上！
11 静态（static）
静态变量（类变量）：对象的共有属性，其生命周期大于对象。静态变量一般不许修改 。public static final String COUNTRY=“China”;
静态函数（类方法）：只要该函数不直接调用成员变量或成员方法，则可以静态。
（1）不能把所有的变量都定义成static，所有的人都是一样的，就不存在对象的概念，大家都是同一个人。
（2）静态变量与成员变量的区别
生命周期：成员变量随着对象的创建而存在，随着对象的销毁而消失
静态变量随着类的加载而存在，随着类的消失而消失

调用方式：成员变量只能通过对象实例化后调用，即对象.变量名
静态变量，既可以直接通过类调用，也可以通过对象调用，即对象.变量名或类名.变量名。

别名： 成员变量也叫实例变量，对象特有属性
静态变量也叫类变量，对象的共有属性
数据存储位置：成员变量存储在堆内存中对象的所属空间里
静态变量存储在方法区中的静态方法区里
方法区：是内存中临时存储应用程序代码(二进制)的地方。

public class OOPDemoC {
	int a;
	public static void main(String[] args) {
		//在静态方法中不能直接访问非静态的变量
		//System.out.println(a);//Cannot make a static reference to the non-static field a
		//静态方法的生命周期大于成员变量，所以无法直接访问，但创建对象后，
		//通过对象在静态方法中直接访问非静态的变量
		OOPDemoC oc=new OOPDemoC();
		System.out.println(oc.a);
// 		Chinese ch1=new Chinese();
// 		ch1.country="Japan";
// 		System.out.println(ch1.country);//结果为Japan
// 		Chinese ch2=new Chinese();
// 		System.out.println(ch1.country);//结果为Japan
 		//既然静态变量为共有属性，那么不能私自修改，将其定义为常量
		Chinese ch1=new Chinese("小明",10);
		//ch1.country="Japan";//country cannot be resolved or is not a field,无法修改
		System.out.println(ch1.COUNTRY);
		ch1.show();
		Chinese ch2=new Chinese("小李",20);
		System.out.println(ch2.COUNTRY);
		System.out.println(Chinese.COUNTRY);
		ch2.show();
	}
}
class Chinese{
	public static final String COUNTRY="China";
	String name;
	int age;
	Chinese(String name,int age){
		this.name=name;
		this.age=age;
	}
	void show(){
		System.out.println(name+age+COUNTRY);
	}
}

①javac OOPDemoA.java 将源代码进行编译，生成.class文件 OOPDemoA.class 和Chinese.class。（javac Chinese.java也可以编译，但运行时只能运行OOPDemoA，因为它里有主函数）
②java OOPDemoA 将OOPDemoA.class和Chinese.class文件加载进JVM里
③将.class文件分为静态区和非静态区
④JVM会在静态方法区里寻找OOPDemoA空间中主函数！
⑤主函数进栈，开始执行代码；
⑥开辟空间 分配地址 然后对对象的成员变量进行默认初始化
⑦再对成员变量进行显式初始化
⑧相应构造函数进栈 (this)进行针对性初始化
⑨构造函数弹栈 将地址赋予函数中的局部变量
⑩对象在调用变量时，先在堆里找，再去静态方法区里找
⑪成员函数在访问变量时，先在函数中找局部变量，再找堆，后在静态方法区里找

12
①显式初始化,其实是在构造函数进栈时运行的。
②A a=new A();成员变量是该类的一个对象时，不要在其右侧初始化，主函数（A a=new A()）一进栈，在堆内存中创建对象，默认初始化，显示初始化时构造函数进栈 ，然后成员变量A a=new A()中又创建对象，默认初始化，显示初始化时构造函数进栈否则构造函数会一直进栈，发生栈溢出异常
③构造函数中尽量避免创建该类对象 也会引起构造函数不停进栈
即构造函数中创建该类对象导致递归问题，即递归调用构造函数
④static B b=new B();//此对象的创建于主函数无关，随着类的加载对象已经创建。静态变量在加载时已经创建对象，new B 一个对象已经在堆中产生，构造函数不会显示初始化，因为没有成员变量

public class Demo1 {
	public static void main(String[] args) {
		/*A a=new A();//java.lang.StackOverflowError栈溢出异常
		//主函数一进栈，在堆内存中创建对象，默认初始化，显示初始化时构造函数进栈 
		//然后成员变量A a=new A()中又创建对象，默认初始化，显示初始化时构造函数进栈
		//构造函数一直进栈，因此发生栈溢出异常
		System.out.println(a=a.a);
		System.out.println(a=a.a.a);
		*/
		B b=new B();
		System.out.println(b==b.b);
		System.out.println(b==b.b.b);
		System.out.println(b.b==b.b.b);
		//结果false  false true
	}

}
class A{
	//显式初始化 其实是在构造函数进栈时运行的
	//成员变量是该类的一个对象
	//A a=new A();//成员变量是该类的一个对象时，不要在其右侧初始化
	
	A a;
	A(){
		a=new A();//构造函数中尽量避免创建该类对象 也会引起构造函数不停进栈
				  //构造函数中创建该类对象导致递归问题，即递归调用构造函数
	}			 
}
class B{
	static B b=new B();//此对象的创建于主函数无关，随着类的加载对象已经创建
	//静态变量在加载时已经创建对象，new B 一个对象已经在堆中产生 
	//构造函数不会显示初始化，因为没有成员变量 
}

13. 静态代码块：仅在类加载时执行一次，为类进行初始化，优先于局部代码块和构造代码块
    局部代码块：
    构造代码块：在创建对象时执行，为对象进行初始化，且每创建一个对象就要执行一次，优先于构造函数。

public class OOPDemoD {
	public static void main(String[] args){
		CodeBlock c1=new CodeBlock();
		CodeBlock c2=new CodeBlock()；	
	}
}
class CodeBlock{
	static{
		//连接数据库
		System.out.println("静态代码块");
	}
	{
		System.out.println("构造代码块");
	}
	CodeBlock(){
		System.out.println("构造函数");
	}
}

运行结果：静态代码块
构造代码块
构造函数
构造代码块
构造函数
14.设计模式：并不是随java的诞生而诞生的，是一些写代码的套路，一些程序员的经验，针对不同的场合和不用的需求设计出来的
单例模式：该类对象只能创建一个
饿汉式
饱汉式
/*设计模式，并不是随java的诞生而诞生的
*是一些写代码的套路，一些程序员的经验，针对不同的场合和不用的需求设计出来的 */
/单例模式：该类对象只能创建一个
（1）.如果给外界提供new的调用，则外界向创建多少对象就可以创建多少
但new只是关键字，无法对它进行限制，但是对象的创建时需要构造函数进栈，
所以为了不让外界创建对象，构造函数私有化（private）
（2）外界无法创建对象，只能内部创建对象，但构造函数私有化，
内部的特有属性外界无法访问，只能让其为static（公有属性）
能是成员变量？不可以，无法创建对象
能是局部变量？不可以局部变量就意味着提供了一个函数来创建对象，只要调用
该函数就可以创建对象，调用10次创建10个对象/
`
public class SingleDemo {
public static void main(String[] args) {
//Single s=new Single();构造函数一旦私有，外界无法创建对象
//Single.s=null;//static Single s=new Single();不加private直接就可以访问并修改
Single1 s1=Single1.getInstance();//public Single getInstance()不加static,外界已经没法创建对象，无法调用该函数
Single1 s2=Single1.getInstance();
Single1 s3=Single1.getInstance();
System.out.println(s1s2);
System.out.println(s1s3);
Single2 s4=Single2.getInstance();
Single2 s5=Single2.getInstance();
Single2 s6=Single2.getInstance();
System.out.println(s4s5);
System.out.println(s4s6);
//System.out.println(s1s4);Incompatible operand types Single1 and Single2
}
}
class Single1{//饿汉式
//static Single s=new Single();
private static Single1 s=new Single1();
//private static final Single1 s=new Single1();不能改变，将其定义为常量
private Single1(){}
public static Single1 getInstance(){
return s;
}
}
class Single2{//饱汉式
private static Single2 s=null;//不能加final，下面将其改变了
private Single2(){}
public static Single2 getInstance(){
if(snull){
s=new Single2();
return s;
}
return s;
}
}
运行结果：true
true
true
true