/*一般函数与构造函数的区别

构造函数：对象创建时，就会调用与之对应的构造函数，对对象进行初始化

一般函数：对象创建时，需要函数功能时才调用

构造函数：一个对象对象创建时，只调用一次

一般函数：对象创建时，可以被调用很多次

*/

/*当成员变量和局部变量重名时。可以用this来区分

this:代表对象。 代表那个对象？当前对象

this就是所在函数所属对象的引用

简单的说：那个对象调用了this所在的函数，this就代表那个对象

    this也可以用于在构造函数中调用其他构造函数

   注意：只能定义在构造函数的第一行。因为初始化函数要先执行

public Demo(String name,int age)

{

	this.name=name;

	this.age=age;

}

public boolean bijiao(Demo p)

{

	return this.age=p.age；

}

pyblic static void main(String[] args)

{

Demo p1=new Demo("超霸",18);

Demo p2=new Demo("暮雪",20);

	p1.bijiao(p2);

}

*/

/*,String name ///成员变量，实例变量

static String name //静态变量，类变量

成员变量and静态变量的区别？

1，两个变量的生命周期不同

成员变量随着对象的创建而存在，随着对象被回收而释放

静态变量随着类的加载而存在，随着类的消失而消失

2，调用方式不同

成员变量只能被对象调用

静态变量可以被对象调用，还可以被类名调用

3，数据存储位置不同

成员变量数据存储在堆内存中，所以也叫对象的特有数据

静态变量存储在方法区的静态区，所以也叫对象的共享数据

*/

/*静态使用的注意事项

1，静态方法只能访问静态成员。（非静态既可以访问静态，又可以访问非静态）

2，静态方法中不可以使用this或者super关键字

3.主函数是静态的

静态在方法区的静态区，栈内

4.静态什么时候用？

1静态变量

2.静态方法

*/

1

/*extends继承 implements接口继承   public class 类名 implements 接口A,接口B{类体}

public interface 接口a extends 接口B{

	常量定义   方法声明

}

class 子类 extends 父类 

*/

class Person

{

	String name;

int age;

}

class Student extends Person

{

//String name;

//int age;

void study()

	{

	System.out.println("good good student study");

}

}

/*abstract 抽象类and接口

abstract class 类名{{类体}

abstract void show();

抽象类：笼统，模糊，看不清。不具体

特点

1.方法只有声明没有实现时。该方法就是抽象方法。需要被abstract

抽象方法必须定义在抽象类中

2.抽象类不可以被实例化，为什么？因为调用抽象方法没意义

3.抽象类必须有其子类覆盖了所有的抽象方法后，该子类才可以实例化

否则，这个子类还是抽象类。

1.抽象类中有构造函数吗

有。用于给子类对象进行初始化

2.抽象类可以不定义抽象方法吗？

可以的。但是很少见，目的就是不让该类创建对象。AWT的适配器对象就是这种类

通过这个类中的方法有方法体。但是却没有内容

abstract  class Demo{

	void show1（）

	{}

	void show2（）

	{}

}

3.抽象函数不可以和那些关键字共存？

************抽象方法要被覆盖

private 不行

static 不行  静态无法被覆盖  静态不需要对象。无意义

final 不行。。最终的，无法被覆盖

4.抽象类和一般类的区别

相同点：

      抽象类和一般类都是用来描述事物的。都在内部定了成员

	  不同：

	  1.一般类有足够的信息描述事物

	  抽象类描述的信息有可能不足。

	  2.一般类中不能定义抽象方法。只能定义非抽象方法

	  抽象类中可定义抽象方法。同时科院定义非抽象方法

	  3.一般类可以被实例化

	  抽象类不可以被实例化

5.抽象类一定是个父类吗？

是的。因为需要子类覆盖其方法后才可以对子类实例化

定义接口关键字

interface Demo

{	常量定义   方法声明

	abstract void show1();

}

对于接口中的常见的成员，而且这些成员都有固定的修饰符

全局常量 public static  final

抽象方法 public abstract

接口中的成员都是公共权限

interface 类名{

接口的定义

类与类之间是继承关系 类与接口直接是实现关系

接口不可以实例化

只能由实现了接口的子类并覆盖了接口中所有的抽象方法后，该子类才可以实例化

否则这个子类就是一个抽象类

}

抽象类和接口的异同点

不同点：1.抽象类需要被继承，而且只能单继承

接口需要被实现。而且是多实现。

2.抽象类中可以定义抽象方法和非抽象方法，子类继承后，可以直接使用非抽象方法。

接口中只能定义抽象方法，必须由子类去实现

3.抽象类的继承是is a关系，在定义该体系的基本共性内容

接口的实现是like a关系，在定义体系额外功能。

*/

/*对象的多态性

class 动物

{}

class 猫 extends 动物

{}

class 狗 extends 动物

{}

猫 x= new 猫();

动物 X=new 猫();  一个对象。2中形态

猫这类事物即具备猫的形态，又具备着动物的形态。这就是对象的多态性

简单说：就是一个对象对应着不同类型

多态在代码中的体现

父类或者接口的引用指向其子类的对象

*/

/*内存的划分

1寄存器

2本地方法区

3方法区

4栈内存

    存储的都是局部变量，局部变量一结束就消失

	变量一旦离开作用域一旦结束。改变量就自动释放

	生命周期短，更新快

5堆内存

存储的是数组和对象（其实数组就是对象），凡是new建立的都在堆中。

实体用来封装存储对象多个数据。

堆特点

1.每个实体都有首地址

2.堆内存中没一个变量都有默认初始化值，根据类型的不同而不同

3.垃圾回收机制

public class CalcDemo1 {

	public static void main(String[] args) {

		for(int x=0;x<5;x++)

		{

		}

		System.out.println(x);

	}

}

*/

/*设计模式

对问题行之有效的解决方式。其实它是一中思想

单例设计模式

解决的问题：就是可以保证一个类在内存中的对象唯一性

如：对于多个程序使用同一个配置信息对象时，就需要保证该对象的唯一性

如何保证对象唯一性？

1.不允许其他程序用new创建该类对象。

2.在该类创建一个本类实例

3.对外提供一个方法让其他程序可以获取该对象

步骤

私有化该类构造函数

通过new在本类中创建一个本类对象

定义一个公有方法，讲创建的对象返回

*/

/*单列设计模式。保证对象唯一性

class  SingleDemo

{

	public static void main(String[] args)

	{

	Singel t1=Singel.getInstance();

Singel t2=Singel.getInstance();

t1.setNum(10);

t2.setNum(20);

System.out.println(t1.getNum());

System.out.println(t2.getNum());

	}

}

对象唯一性实现方法

class Singel  //饿汉式  类一加载。对象就已经存在了。。一般用这个

{

	private int num;

	private static Singel s=new Singel();

	private Singel(){}

	public static Singel getInstance()

	{

		return s;

	}

public void setNum(int num)

{

	this.num=num;

}

public int getNum()

	{

return num;}

}

class Singel2  //类加载进来，没有对象。只有调用get方法时，才会创建对象  懒汉式

{

	private static Singel2 s=null;

	private Singe12(){}

	public static Singel2 getinfo()

	{

		if(s==null)

			s=new Singel2();

		return s;

	}

}

*/

/*Thread多线程  继承   重写run方法。代码放在run中   start启动线程并调用run方法

*/