/*一般函数与构造函数的区别
构造函数：对象创建时，就会调用与之对应的构造函数，对对象进行初始化
一般函数：对象创建时，需要函数功能时才调用
构造函数：一个对象对象创建时，只调用一次
一般函数：对象创建时，可以被调用很多次
*/
/*当成员变量和局部变量重名时。可以用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方法
*/