初学java(3)

六、面向对象
4.主函数
public static void main(String[] args)
主函数：是一个特殊的函数，作为程序的入口，可以被jvm调用
定义：
public：代表着该函数的访问权限是最大的
static:代表着主函数随着类的加载就已经存在了
void：主函数没有具体的返回值
main：不是关键字，但是是一个特殊的单词可以被jvm识别
（String[] arr）函数的参数：函数的参数，参数类型是一个数组，该数组中的元素是字符串，字符串类型的数组

主函数是固定格式的：jvm识别
jvm在调用主函数时，传入的是new String[0];

public class 主函数 {

public static void main(String[] args) //new String
{
// TODO Auto-generated method stub
System.out.println(args.length);
for(int x=0;x<args.length;x++)
System.out.println(args[x]);
String[] arr = {“hah”,“heh”,“heihei”,“xixi”,“hiahia”};
MainTest.main(arr);

}
}
class MainTest //调用主函数的应用
{
public static void main(String[] args)
{
for(int x=0;x<args.length;x++)
System.out.println(args[x]);
}
}

5.This 关键字
public class this关键字 {

public static void main(String[] args) {
// TODO Auto-generated method stub

Person t = new Person(“lisi”);
Person t1 = new Person(“Zhangsan”);
t.speak(); //this代表t
t1.speak();
/**********************************************************************/
Person p1 = new Person(20);
Person p2 = new Person (25);
boolean b =p1.compare(p2);
System.out.println(b);
/***********************************************************************/
}

}
this: 看上去，是用于区分局部变量和成员变量同名的情况

• this 为什么可以解决这个问题呢？
• this到底代表的是什么呢？
• this就代表本类的对象，到底代表哪一个呢？
  this 代表他所在函数，所属对象的引用
  简单说，哪个对象在调用this所在函数，this就代表哪个对象
  this的应用：当定义类功能时，该功能内部要用到该函数时，这时用this来表示对象
  但凡本类功能使用到了本类对象，都用this表示
  this语句不能用在一般函数中，只能在构造函数中的起始位置调用
  this语句用于构造函数间调用，构造函数间调用只能用this语句（用的时候得传相对应的参数）
  this语句只能放构造函数第一行，第一个语句
  初始化的动作要先执行（初始化中还有初始化就执行那个细节的初始化）初始化只执行一次
  不允许出现死循环的情况

class Person{
private String name = “haha”;
private int age;
private static String country = “cn”;
Person (int age)
{
this.age = age;
}
Person(String name){
this.name = name; //第一个name是成员变量，第二个name是局部变量
}
Person(String name,int age)
{
//this.name = name;
//Person(name);//构造函数间调用不能这么写 （只有构造函数间不能）
this(name);//p(name)
this.age = age;
}
public void speak()
{
System.out.println(“name=”+this.name+"…age="+this.age);
show();
}
}
6.static关键字
/*static（静态）关键字
* 用法：是一个修饰符用于修饰成员（成员变量，成员函数），（在内存中提取出来，静态修饰内容被修饰对象所共享，节省内存）
* 当成员被静态修饰后，就多了一种调用方式，除了可以被对象调用外还可以直接被类名调用（写法/格式：类名.静态成员）
* 特有内容随着对象存储（在堆内存当中）
* 共有内容可用（静态）关键字
* 静态关键字在 方法区里储存
*
* 方法区：（（也叫共享区，数据区）
* static 静态的特点：
* 1）随着类的加载而加载
* 也就是说：静态会随着类的消失而消失，说明它的生命周期最长 对象消失静态也还在（对内存的消耗大）
* 2）优先于对象存在
* 静态先存在，对象后存在
* 3）被所有对象所共享
* 4）可以直接被类名调用
*
* 实例变量和类变量的区别：
* 1）存放位置：
* 类变量随着类的加载而存在于方法区中
* 实例变量随着对象的建立而存在于堆内存中
* 2）生命周期：
* 类变量生命周期最长，随着类的消失而消失 生命周期： 类对象->对象->实例变量
* 实例变量生命周期随着对象的消失而消失
*
*
* 静态使用注意事项：
* 1.静态方法只能访问静态成员 （成员包括方法和变量）
* 非静态方法既可以访问静态也可以访问非静态
* 2.静态方法中不可以定义this,super关键字
* 3.主函数是静态的
* 静态有利有弊
* 利：对对象共享数据进行单独空间的存储节省空间，没必要每一个对象都存储一份
* 可以直接被类名调用
* 弊：生命周期过长，访问出现局限性（静态虽好，只能访问静态）
*
* 因静态优先于对象存在，所以静态方法中不可以出现this
*
* 什么时候使用静态？
* 要从两方面下手
* 因为静态修饰的内容有成员变量和函数
* 什么时候定义静态变量（类变量）呢？
* 当对象中出现共享数据时该数据被静态所修饰
* 对象中的特有数据要定义成非静态存在于堆内存中，
*
* 什么时候定义静态函数呢？（背下来）
* 当功能内部，没有访问到非静态数据（对象的特有数据）
* 那么该功能可以定义成静态的

public class static关键字 {
/static
{
System.out.println(“b”);
}/
public static void main(String[] args) {
// TODO Auto-generated method stub
/* Ren.show();
Ren p =new Ren();
p.name = “zhangsan”;
//p.show();
System.out.println(p.country);
System.out.println(Ren.country);//多了一种调用方式

/**************************************************************/
/*Person a = new Person(); //建立对象–>封装数据
a.show();

/******************************************************************/
int [] arr1 = {3,1,87,32,8};
int max1 = ArrayTool.getMax(arr1);
System.out.println(“max=”+max1);
//class文件中可以互相调用 体现 静态的应用 ！！！
int[] arr1 = {3,1,87,32,8};
ArrayTool tool = new ArrayTool();
int max1 = tool.getMax(arr1);
System.out.println(“max=”+max1);
int min = tool .getMin(arr1);
System.out.println(“min=”+min);
tool.printArray(arr1);
tool.selectSort(arr1);
tool.printArray(arr1);

new StaticCode(); //–>a
new StaticCode(); //不执行
System.out.println(“over”);

//StaticCode.show(); 用到类中内容才加载了
//StaticCode s = null;//s没有任何实体指向，没加载

new StaticCode(4);
}
/static
{
System.out.println(“c”);
}/

}
/*class Ren
{
String name;//成员变量，实例变量 对象在该变量就在，对象不在该变量就不在
static String country = “CN”;//静态的成员变量，类变量
public static void show()
{
System.out.println("::"+country);
}
}

class{
String name;
public static void show() //功能没有操作对象的特有数据，就是静态的

{
System.out.println(“haha”);
}

public void show() //不能写static
{
System.out.println(name+“haha”); //该功能访问到对象中的数据，就不能写static
}
*/

/*静态代码块

• 格式：

• static{

• 静态代码块中的执行语句

• }

• 特点：随着类的加载而执行，只执行一次,并优先与主函数

• 用于给类进行初始化的*/

class StaticCode
{
int num = 9;
StaticCode() // 代码块的执行顺序！！！很重要
{
System.out.println(“b”);
}
static //静态代码块给类初始化
{
System.out.println(“a”); //不能写成System.out.println(“a”+num); 访问不了num
}
//构造代码块 给堆对象初始化
{
System.out.println(“c”+num); //可以访问
}
StaticCode(int x) //构造函数 给对应对象初始化
{
System.out.println(“d”);
}
public static void show()
{
System.out.println(“show run”);
}
}
7.静态的应用

静态的复用
* 每一个应用程序中都有共性的功能
* 可以将这些功能进行抽取，独立封装以便复用
*
* 虽然可以通过建立ArrayTool的对象使用这些工具方法，对数组进行操作
* 但发现了问题
* 1）ArrayTool对象是用于封装数据的，可是ArrayTool对象并未封装特有数据
* 2）操作数组的每一个方法都没有用到ArrayTool对象中的特有数据
*
* 这时就考虑，让程序更严谨，是不需要对象的
* 可以将ArrayTool中的方法都定义成static的，直接通过类名调用即可
* 将方法都静态后，可以方便于使用，但该类还是可以被其他程序建立对象的
* 为了更为严谨，强制让该类不能建立对象
* 可以通过将构造函数私有化完成
class ArrayTool {

public static void main(String[] args) {
// TODO Auto-generated method stub
int [] arr = {3,4,1,8};

int max = getMax(arr);
System.out.println(“max”+arr[max]);
/***************************************************************/
/int[] arr1 = {3,1,87,32,8};
ArrayTool tool = new ArrayTool();
int max1 = tool.getMax(arr1);;
System.out.println(“max=”+max1)
int min = tool .getMin(arr1);
System.out.println(“min=”+min);
tool.printArray(arr1);
tool.selectSort(arr1);
tool.printArray(arr1);/ //在static关键字中体现
}
public static int getMax(int [] arr)
{
int max = 0;
for(int x = 1;x<arr.length;x++)
{
if(arr[x]>arr[max])
max = x;
}
return arr[max];
}
}
class Test
{
public static int getMax(int [] arr)
{
int max =0 ;
for(int x = 1;x<arr.length;x++)
{
if(arr[x]>arr[max])
max = x;
}
return arr[max];
}
}
/**********************************************************************/
* 接下来如果将ArrayTool.class文件发送给别人，其他人只要将文件设置到classpath路径下，就可以 使用该工具类
* 但该类中到底定义了多少个方法，对方不清楚，因为该类并没有使用说明书
*
* 制作程序说明书，java的说明书通过文档注释来完成
*
* 在javadoc中可以生成使用说明书 （API帮助文档） 会生成很多的网页
* 私有后的东西不会出现 没加public 就不会再那个网页中出现
* /
/
* 这是一个可以对数组进行操作的工具类，该类中提供了，获取最值，排序等功能
* @author 张三
* @version v1.1
* /
public class 静态的应用{
/
* 空参数构造函数/
private 静态的应用() {} //私有化 更严谨 自定义构造函数 默认的构造函数不会让你看见
/
* 获取一个整型数组中的最大值
* @param arr 接受一个int类型的数组
* @return会返回一个该数组中的最大值
* */
public static int getMax(int[] arr1)
{
int max1 = 0;
for(int x = 1;x<arr1.length;x++)
{
if(arr1[x]>arr1[max1])
max1 = x;
}
return arr1[max1];
}

/ * 获取一个整型数组中的最小值
* @param arr 接受一个int类型的数组
* @return会返回一个该数组中的最小值
* /
public static int getMin(int [] arr1)
{
int min = 0;
for(int x = 1;x<arr1.length;x++)
{
if(arr1[x]<arr1[min])
min = x;
}
return arr1[min];
}
/*
* 给int 数组进行选择排序
* @param arr接收一个int类型的数组
* /
public static void selectSort(int[] arr1)
{
for(int x=0;x<arr1.length-1;x++)
{
for(int y=x+1;y<arr1.length;y++)
{
if(arr1[x]>arr1[y])
{
swap(arr1,x,y);
}
}
}
}
/*
* 给int 数组进行冒泡排序
* @param arr接收一个int类型的数组
* */
public static void bubbleSort(int[] arr1)
{
for(int x=0;x<arr1.length-1;x++)
{
for(int y=0;y<arr1.length-x-1;y++)
{
if(arr1[y]>arr1[y+1])
swap(arr1,y,y+1);
}
}
}

/**
* 给数组中的元素进行位置的置换
* @param arr接收一个int类型的数组
* @param a 要置换的位置
* @param b 要置换的位置*/
private static void swap(int[] arr1,int a,int b) // 能隐藏的都隐藏
{
int temp = arr1[a];
arr1[a] = arr1[b];
arr1[b] = temp;
}
/**
* 用于打印数组中的元素，打印形式是：[element1,element2…]*/
public static void printArray(int[] arr1)
{
System.out.print("[");
for(int x=0;x<arr1.length;x++)
{
if(x!=arr1.length-1) System.out.print(arr1[x]+", “);
else System.out.println(arr1[x]+”]");
}
}

}

/*
* 一个类中默认会有一个空参数的构造函数
* 这个默认的构造函数的权限和所属类一致
* 如果类被public修饰，那么默认的构造函数也带public修饰符
* 如果类没有被public修饰，那么默认的构造函数，也没有public修饰
*
* 默认构造函数的权限是随着类的变化而变化的*/
8.final关键字
/*final：最终，作为一个修饰符

• 1.可以修饰类，函数，变量
• 2.被final修饰的类不可以被继承,为了避免被子类继承，被子类复写功能 在类前加final
• 3.被final修饰的方法不可以被复写
• 4.被final修饰的变量是一个常量只能被赋值既可以修饰成员变量有可以修饰局部变量
• ***当在描述事物时， 一些数据的出现值是 固定 的，那么这时为了增强阅读性，都给这些值起个名字，方便阅读
• 而这个值不需要改变，所以加上final修饰 作为常量：常量的书写规范所有字母都大写，如果由多个单词组成，
  单词间通过“ _ ”连接
  5.内部类定义在类中的局部位置上时，只能访问该局部被final修饰的局部变量
• */

//public class yhyh //修饰类的修饰符到目前为止就俩：public final

final class yhyh{
void show() {}
}

class yhyh2{
final int x =3; //x终身为3
public static final double MY_PI = 3.14; //全局常量 权限够大
final void show1()
{

}
void show2()
{
final int y = 4; //y终身为4
//y=9; 不允许
}
}
class a extends yhyh2 //无法继承final class yhyh
{
/void show1() //不能被覆盖
{}/
}
public class final关键字 {

public static void main(String[] args) {
// TODO Auto-generated method stub
//new Student();
new BaseStudent().study();
}

}

/***************************************************************************/
当多个类中出现相同功能，但功能主题不同
值时可以进行向上的抽取，这时，只抽取功能定义

9.抽象

抽象类特点：

• 1.抽象方法一定在抽象类中

• 2.抽象方法和抽象类都必须被abstract关键字修饰

• 3.抽象类不可以用new创建对象，因为调用抽象方法没意义

• 4.抽象类中的抽象方法要被使用，必须由子类复写其所有的抽象方法后，建立子类对象调用

• 如果子类只覆盖了部分抽象方法那么该子类还是一个抽象类

• 抽象类和一般类没有太大的不同

• 该如何描述事物就如何描述事物

• 只不过该事物中出现了一些看不懂的东西

• 这些不确定的部分也是该事物的功能，需要明确出现，但无法定义主体

• 通过抽象方法来表示

• 抽象只能修饰类和方法不能修饰变量

• 抽象类比一般类多了抽象方法（抽象函数） 就是在类中可以定义抽象方法

• 抽象类不可以实例化

• 特殊：抽象类中可以不定义抽象方法，这样做仅仅是不让该类建立对象（即那个类没什么意义）

• */
  class Students{
  //abstract void study2(); //abstract 抽象 抽象方法必须存放在抽象类中 抽象可以强迫子类去做一些事

  void sleep()

  {
  System.out.println(“躺着”);
  }
  //abstract void study1();
  /{
  System.out.println(“study”);
  }/
  }
  class ChongCiStudent extends Students
  {
  void study()
  {
  System.out.println(“chongci study”);
  }
  }
  class BaseStudent extends Students
  {
  void study1() {}
  void study()
  {
  System.out.println(“base study”);
  }
  }
  class AdvStuden extends Students{
  void study1() {}
  void study()
  {
  System.out.println(“adv study”);
  }
  }
  /****************************************************************************/
  /*抽象的应用

• 假如我们在开发一个系统是需要对员工进行建模，员工包含3个属性：

• 姓名，工号，以及工资，经理也是员工，除了含有员工的属性外，另外还有一个奖金属性

• 请使用继承的思想设计出员工类和经理类

• 要求类中提供必要的方法进行属性访问
  / *员工类：name id pay
  *经理类： 继承了员工，并有自己特有的奖金属性 bonus

• */

abstract class Employee
{
private String name;
private String id;
private double pay;
Employee (String name,String id,double pay)
{
this.name = name ;
this.id = id;
this.pay = pay;
}
public abstract void work();
}

class Pro extends Employee
{
Pro (String name,String id,double pay)
{
super(name,id,pay);
}
public void work()
{
System.out.println(“pro work”);
}
}

class Manager extends Employee
{
private int bonus;
Manager(String name,String id,double pay,int bonus)
{
super(name,id,pay);
this.bonus = bonus;
}
public void work()
{
System.out.println(“manager work”);
}
}
10.继承
/*继承：
*1.提高了代码的复用性
*2.让类与类之间产生了关系，有了这个关系，才有了多态的特性
*
*
*弊端：打破了封装性
*
*注意：千万不要为了获取其他类的功能简化代码而继承，必须是有类与类之间有所属关系才可以继承
*所属关系 is a .
*
*子类应该具备父类中的内容
*先有的父类 后期产生的子类
*
*class C //C是通过找共性不断抽取出来的
{
*void demo 1(){}
*}
*
*class A extends C
*{

• //void demo1(){}
  *void demo2(){}
  *}

*class B extends C
*{

• //void demo1(){}
  *void demo3(){}
  *}

*在java 语言中，java只支持单继承，不支持多继承
*
*因为多继承容易带来安全隐患,当多个父类中定义了相同功能，当功能内容不同时，子类对象不确定要运行哪一个
*但是java保留这种机制，并用另一种体现形式来完成表示。 多实现。
*
*java支持多层继承 也就是继承一个体系
*如何使用一个继承体系中的功能呢？
*想要使用体系，先查阅体系父类的描述，因为父类中的定义的是该体系中共性功能
*通过了解共性功能，就可以知道该体系的基本功能
*那么这个体系，已经可以基本使用
*
*那么在具体调用时要创建最子类的对象，为什么呢？
*一是因为有可能父类不能创建对象
*二是创建子类对象可以使用更多的功能，包括基本的也包括特有的
*
*简单概括：查阅父类功能，创建子类对象使用功能
*
*
*class A{
*void show()
*{ System.out.println(“a”); }

• }

• class B

• { void show()

• {System.out.println(“b”); }

• }

• class C extends A,B

• {

• C c = new C();

• c.show();}
  */
  public class 继承 {
  public static void main(String[] args) {
  // TODO Auto-generated method stub
  // Zi z = new Zi();
  //System.out.println(z.num1+"…"+z.num2);

  Zi z = new Zi();
  Zi z1 = new Zi(4);
  }

}

class Person {
String name;
int age;
}
class Student extends Person //extends使学生和人之间产生关系
{
//String name;
//int age;

void study()
{
System.out.println(“good Study”);
}
}

class Work extends Person
{
String name ;
int age;
void work()
{

System.out.println(“good work”);
}
}

/*聚集：has a

• 聚合:
• 组合：
• */

/******************************************************************************/
/*子父类出现后，类成员的特点：(变量，函数，构造函数)

• 类中成员：
• 1.变量
• 如果子类中出现非私有的同名成员变量时，
• 子类要访问本类中的变量，用this
• 子类中要访问父类中的同名变量，用super
• super的使用和this的使用几乎一致
• this代表的是本类对象的引用
• super代表的是父类对象的引用
• 变量
• class Fu
  {
  private int num=4;
  }
  class Zi extends Fu
  {
  int num = 5;
  void show()
  {
  System.out.println(super.num);
  }
  }
• 2.函数
• 子父类中的函数
• 当子类出现和父类一模一样的函数时
• 当子类对象调用该函数，会运用子类函数的内容
• 如同父类的函数被覆盖一样
• 这种情况是函数的另一种特性：重写（覆盖）
• 当子类继承父类，沿袭了父类的功能，到子类中，但是子类虽具备该功能，但是功能的内容却和父类不一致
• 这时，没有必要定义新功能，而是使用覆盖特性 ，保留父类的功能定义，并重写功能内容
• 覆盖：
• 1.子类覆盖父类，必须保证子类权限大于等于父类权限
• 2.静态只能覆盖静态
• 记住：
• 重载：只看同名函数的参数列表
• 重写：子父类方法要一模一样
• /*函数
  class Fu
  {
  void show() //啥也不写叫默认权限，默认权限介于公有和私有之间
  {
  System.out.println(“fu show”);
  }
  private void speak()
  {
  System.out.println(“vb”);
  }
  }
  class Zi extends Fu
  {
  void show()
  {
  System.out.println(“zi show”);
  }
  void speak2()
  {
  System.out.println(“java”);
  }
  }

class Tel
{
void show()
{
System.out.println(“number”);
//System.out.println(“name”);//尽量不要改源码 灾难
}
}
class NewTel extends Tel //复写
{
void show()
{
super.show(); //System.out.println(“number”);
System.out.println(“name”);
System.out.println(“pic”);
}
}*/

/*3.构造函数
*

• 在对子类对象进行初始化时，父类的构造函数也会运行

• 这是因为子类的构造函数默认第一行有一条隐式的语句 super（）；

• super（）：会访问父类中空参数的构造函数，而且子类中所有的构造函数默认第一行都是super（）

• 为什么子类一定要访问父类中构造函数？

• 因为父类中的数据子类可以直接获取，所以子类对象在建立时，需要先查看父类是如何对这些数据进行初始化的

• 所以子类在对象初始化时要先访问一下父类中的构造函数

• 如果要访问父类中指定的构造函数可以通过手动定义super语句的方式来指定

• super语句必须写构造函数的第一行 先去父类初始化再找自己

• 谁用super谁是子类

• 子类的实例化过程:

• 结论：

• 子类中的所有的构造函数，默认都会访问父类中空参数的构造函数

• 因为子类每一个构造函数内第一行都有一句隐式super（）；

• 当父类中没有空参数的构造函数时，子类必须手动通过super语句形式来指定要访问的构造函数

• 当然，子类的构造函数第一行也可以手动指定this语句来访问本类中的构造函数，子类中至少会有一个构造函数

• 会访问父类中的构造函数*/
  class Fu //extendx Object 所有类的父类
  {
  int num =2;
  Fu()
  {
  System.out.println(“fu run”);
  }

  Fu(int x)

  {
  System.out.println(“fu…”+x);
  }

}
class Zi extends Fu //子类中至少会有一个函数访问父类 所以子类中有一个写this没事，但不能都写
{
Zi()
{
//super();
super(4);
System.out.println(“zi run”);
}
Zi(int x)
{
// this(); super(); 构造函数里一定要不有this要不有super， this super不能共存
//super();
super(3);
System.out.println(“zi…”+x);
}
}

/*
class Person2
{
private String name;
Person2(String name)
{
this.name = name;
}
void show()
{}
}
class Student2 extends Person2
{
Student2(String name)
{
super(name); //子类想调用父类中的构造函数不能写super. 得写super（）
}
void method()
{
super.show();//子类想调用一般函数用super.
}
}
父类中定义好的功能子类中直接用就行了，子类中不用再次定义
*/
11.单例1
/*设计模式：偏思想 23种通用模式

• 解决某一类问题最行之有效的方法

• 其中一种

• 单例设计模式：解决一个类在内存中只存一个对象

• 想要保证对象唯一

• 1.为了避免其他程序过多建立该类对象，先禁止其他程序建立该类对象

• 2.还为了让其他程序可以访问到该类对象，只好在本类中，自定义一个对象

• 3.为了方便其他程序对自定义对象的访问，可以对外提供一些访问对象

• 如何体现这三步呢？

• 1.将构造函数私有化

• 2.再累中创建一个本类对象

• 3.提供一个方法可以获取到该对象

• */

class Single1
{
private int num;
public void setNum(int num)
{
this.num = num;
}
public int getNum()

{
return num;
}
private Single1() {
}
private static Single1 s = new Single1();
public static Single1 getInstance()
{
return s;
}
}
public class 设计模式 {

public static void main(String[] args) {
// TODO Auto-generated method stub
//Single ss = Single.getInstance();
/Single s1 = new Single();
Single s2 = new Single();
s1.setNum(30);
System.out.println(s2.getNum());/
Single1 s1 = Single1.getInstance();
Single1 s2 = Single1.getInstance();
s1.setNum(23);
System.out.println(s2.getNum());
/******************************************************************/
Student a1 = new Student();
a1.setAge(30);
Student a2 = new Student();
a2.setAge(12);
//不加三步时的写法

Student a1 = Student.getStudent();//加上的写法
Student a2 = Student.getStudent();

}

}
/*对于事物该怎么描述，还怎么描述

• 当需要将该事物的对象保证在内存中唯一时，就将以上的三部加上即可*/
  class Student {
  private int age;

  //加上的三部
  private static Student a = new Student();
  private Student () {}
  public static Student getStudent()
  {
  return a;
  }
  //到此结束的，加完了的三部

  public void setAge(int age)
  {
  this.age = age;
  }
  public int Age()
  {
  return age;
  }
  }
  12.单例2
  public class 单例{

  public static void main(String[] args) {
  // TODO Auto-generated method stub
  //GetTime gt = new GetTime();

  SubTime gt = new SubTime();
  gt.getTime();
  }

}
/*这个是先初始化

• 称为：饿汉式
• Single类一进内存，就已经创建好了对象
• class Single
  {
  private static Single s = new Single();
  private Single () {}
  public static Single getSingle()
  {
  return s;
  }
  public void show()
  }*/

/*
对象是方法被调用时，才初始化，也叫做对象的延时加载
称为：懒汉式
Single类进内存，对象还没有存在，只有调用了getInstance方法时，才建立对象
*/

/*记住原则：定义单例，建议使用饿汉式 */
/*****************************************************************************/
/*需求：获取一段程序运行的时间

• 原理：获取程序开始和结束的时间并相减即可
• 获取时间：System.currentTimeMillis();
• 当代码完成优化后就可以解决这类问题
• 这种方式，模板方法设计模式
• 什么事模板方法呢
  *在定义功能时，功能的一部分时确定的，但是有一部分是不确定的，而确定的部分在使用不确定的部分
  那么这时就将不确定的部分暴露出去，由该类的子类去完成/

abstract class GetTime //获取某段代码时间
{
public final void getTime() //final避免覆盖（复写）
{
long start = System.currentTimeMillis();
runcode();
long end = System.currentTimeMillis();
System.out.println(“毫秒：”+(end-start));
}
/public void runcode()
{
for(int x=0;x<1000;x++)
{
System.out.println(x);
}
}/
public abstract void runcode();// 不确定–>抽象 （ 不一定非得抽象的 看模板）
}
class SubTime extends GetTime
{
public void runcode()
{

for(int x=0;x<4000;x++)
{
System.out.print(x);
}
}
}
13.接口

public class 接口 {
/*接口：
* 初期理解，可以认为是一个特殊的抽象类
* 当抽象类中的方法都是抽象的，那么该类可以通过接口的形式来表示
* class用于定义类
* interface用于定义接口
* 接口定义时 ，格式特点：
* 1.接口中常见定义：常量，抽象方法，
* 2.接口中的成员都有固定修饰符
* 常量：public static final
* 方法：public abstract
* 记住：接口中的成员都是public的
* 接口的权限是固定的
*
* 接口是不可以创建对象的，因为有对抽象方法
* 需要被子类实现，子类对接口中的抽象方法全都覆盖后，子类才可以实例化
* 否则子类是一个抽象类
*
* 接口可以被类多实现 （一个类可以实现多个接口）
* 也是对多继承不支持的转换形式，java支持多实现
*
* 接口的特点：
* 1.接口是对外暴露的规则
* 2.接口是程序的功能扩展
* 3.接口可以用来多实现
* 4.类与接口之间是实现关系，而且类可以继承一个类的同时实现多个接口
* 5.接口与接口之间可以有继承关系（只有接口与接口之间可以多继承）
* */
public static void main(String[] args) {
// TODO Auto-generated method stub
Test t = new Test();
System.out.println(t.NUM);
System.out.println(Test.NUM);
System.out.println(Inter.NUM);
}

}
interface Inter //接口里的内容全抽象
{
public static final int NUM = 3; // public static final都可以不写

public abstract void show(); //public abstract 可以不写

}

interface InterA
{
//public abstract void method();
public abstract void show();
}
class lalala
{
public void function()
{
}
}

class Test extends lalala implements Inter,InterA //一个类在继承一个类的同时还能实现多个接口
{
public void show(){}
//public void method() {}
}

/*类与类之间是 继承关系

• 类与接口之间是 实现关系
• 接口与接口之间是 继承关系*/

interface A
{
void methodA();
//int show(); 不能同时出现
}
interface B //extends A
{
void methodB();
//boolean show();

}
interface C extends B,A
{
void methodC();
}
class D implements C
{
public void methodA() {}
public void methodB() {}
public void methodC() {}
// public int show(){} 调用错误
// public boolean show() {}
}

//只有接口之间存在多继承 类与类之间只支持单继承

/*基本内容定义在类中

• 扩展功能定义在接口中 体系外的用接口来表示

• */
  /*abstract class Student
  {
  abstract void study();
  void sleep()
  {
  System.out.println(“sleep”);
  }
  }

interface Smoking
{
void smoke();
}
class ZhangSan extends Student implements Smoking
{
void study(){}
public void smoke() {}
}
class Lisi extends Student{

}
*/
14.对象类型的转换
/*1.向上转型

• 就是把子类对象赋值给父类类型的变量
• 多态机制的基本思想：
• 根据不同的对象设置不同的类型之上，这就是多态做到在父类中定义一个方法完成各个子类的功能
• 这样可以使同一份代码毫无差别地运用到不同类型之上
  2.向下转型
  子类对象总是父类的一个实例，但父类对象不一定是子类的实例
  如果将父类对象直接赋予子类，会发生编译错误，因为父类的对象不一定是子类的实例
  越是具体的对象具有的特性越多，越抽象的对象具有的特性越少
  将特性范围小的对象转换为特性范围大的对象肯定会出现问题
  这时需将父类对象强制转换为某个子类对象，这种方法称为显示类型转换

3.使用instanceof操作符判断对象类型
判断是否一个类实现了某个接口，也可以用它来判断一个实例对象是否属于一个类
语法格式：
myobject instanceof ExampleClass
myobject:某类的对象引用
ExampleClass:某个类
使用instanceof操作符的表达式返回值为布尔值，如果返回值为true，说明myobject对象为
ExampleClass的实例对象：如果返回值为false，说明myobject对象不是ExampleClass的实例对象/
/class 对象类型的转换
{
public static void draw(对象类型的转换 q) //四边形类中的方法
{
//SomeSentence
}
}
class Lilili extends 对象类型的转换{ //平行四边形类，继承了四边形类
public static void main(String[] args) {
// TODO Auto-generated method stub
Lilili p = new Lilili();//实例化平行四边形类对象引用
draw§; //调用父类方法
/*************************************************************************/
/ draw(new Lilili());
//将平行四边形类对象看作是四边形对象，称为向上转型操作
对象类型的转换 q = new Lilili();
//Parallelogram p = q;
//将父类对象赋予子类对象，这种写法是错误的
//将父类对象赋予子类对象，并强制转换为子类型，这种写法值正确的
Lilili b = (Lilili)q;
}

}*/

//向下转型与instanceof操作符结合的例子
class 对象类型的转换
{
public static void draw(对象类型的转换 q)
{
//SomeSentence
}
}
class Square extends 对象类型的转换
{
//SomeSentence
}
class Parallelogram extends 对象类型的转换
{
public static void main(String arg[])
{
对象类型的转换 q = new 对象类型的转换(); //实例化父类对象
//判断父类对象是否为Parallelogram子类的一个实例
if(q instanceof Parallelogram)
{
Parallelogram p = (Parallelogram)q; //向下转型操作

}
//判断父类对象是否为Square子类的一个实例
if(q instanceof Square)
{
Square s = (Square)q; //进行向下转型操作
}
//由于q对象不为Anything类的对象，所以这条语句是错误的
//Sstem.out.println(q instanceof Anything);
}
}