黑马程序员---java基础之day8-9
------- android培训、java培训、期待与您交流！ ----------
第八天：
对象数组工具的建立：
class ArrayToolDemo
{
/*
保证程序的独立运行。
*/
public static voidmain(String[] args)
{
int[] arr ={4,8,2,9,72,6};
// ArrayTooltool = new ArrayTool();
// intmax= ArrayT8ool.getMax(arr);
// System.out.println("max="+max);
int index =ArrayTool.getIndex(arr,8);
System.out.println("index="+index);
}
}
//文档注释：javadoc
/**
建立一个用于操作数组的工具类，其中包含着常见的对数组操作的函数如：最值，排序等。
@author 张三
@version V1.0
*/
public class ArrayTool
{
private ArrayTool(){}//该类中的方法都是静态的，所以该类是不需要的创建对象的。为了保证不让其他成创建该类对象
//可以将构造函数私有化。
/**
获取整型数组的最大值。
@paramarr 接收一个元素为int类型的数组。
@return该数组的最大的元素值
*/
public static intgetMax(int[] arr)
{
int maxIndex = 0;
for(int x=1;x { if(arr[x]>arr[maxIndex]) maxIndex= x;// } return arr[maxIndex]; } /** 对数组进行选择排序。 @paramarr 接收一个元素为int类型的数组。 */ public static voidselectSort(int[] arr) { for(int x=0;x { for(inty=x+1; y { if(arr[x]>arr[y]) swap(arr,x,y); } } } /* 用于给数组进行元素的位置置换。 @paramarr 接收一个元素为int类型的数组。 @parama @paramb */ private static voidswap(int[] arr,int a,int b) { int temp =arr[a]; arr[a] = arr[b]; arr[b] = temp; } /** 获取指定的元素在指定数组中的索引. @paramarr 接收一个元素为int类型的数组。 @paramkey 要找的元素。 @return返回该元素第一次出现的位置，如果不存在返回-1. */ public static intgetIndex(int[] arr,int key) { for(int x=0;x { if(arr[x]==key) returnx; } return -1; } /** 将int数组转换成字符串。格式是：[e1,e2,...] @paramarr 接收一个元素为int类型的数组。 @return返回该数组的字符串表现形式。 */ public static StringarrayToString(int[] arr) { String str ="["; for(int x=0;x { if(x!=arr.length-1) str= str + arr[x]+", "; else str= str + arr[x]+"]"; } return str; } } 面向对象的设计模式（一种思想）： /* 设计模式：对问题行之有效的解决方式。其实它是一种思想。 1,单例设计模式。 解决的问题：就是可以保证一个类在内存中的对象唯一性。 必须对于多个程序使用同一个配置信息对象时，就需要保证该对象的唯一性。 如何保证对象唯一性呢？ 1，不允许其他程序用new创建该类对象。 2，在该类创建一个本类实例。 3，对外提供一个方法让其他程序可以获取该对象。 步骤： 1，私有化该类构造函数。 2，通过new在本类中创建一个本类对象。 3，定义一个公有的方法，将创建的对象返回。 */ //饿汉式 class Single//类一加载，对象就已经存在了。 { private static Single s= new Single(); private Single(){} public static SinglegetInstance() { return s; } } //懒汉式(存在安全隐患，多线程操作时，不能保证对象的唯一性。单线程使用效率高) class Single2//类加载进来，没有对象，只有调用了getInstance方法时，才会创建对象。 //延迟加载形式。 { private static Single2 s= null; private Single2(){} public static Single2getInstance() { if(s==null) s = newSingle2(); return s; } } class SingleDemo { public static voidmain(String[] args) { Single s1 =Single.getInstance(); Single s2 =Single.getInstance(); System.out.println(s1==s2); // Singless = Single.s; // Testt1 = new Test(); // Testt2 = new Test(); Test t1 =Test.getInstance(); Test t2 =Test.getInstance(); t1.setNum(10); t2.setNum(20); System.out.println(t1.getNum()); System.out.println(t2.getNum()); } } class Test { private int num; private static Test t =new Test(); private Test(){} public static TestgetInstance() { return t; } public void setNum(intnum) { this.num = num; } public int getNum() { return num; } } 继承： /* 继承的好处： 1，提高了代码的复用性。 2，让类与类之间产生了关系，给第三个特征多态提供了前提. java中支持单继承。不直接支持多继承，但对C++中的多继承机制进行改良。 单继承：一个子类只能有一个直接父类。 多继承：一个子类可以有多个直接父类(java中不允许,进行改良) 不直接支持，因为多个父类中有相同成员，会产生调用不确定性。 在java中是通过"多实现"的方式来体现。 java支持多层(多重)继承。 C继承B，B继承A。 就会出现继承体系。 当要使用一个继承体系时， 1，查看该体系中的顶层类，了解该体系的基本功能。 2，创建体系中的最子类对象，完成功能的使用。 class Demo { voidshow1(){} } class DemoA extends Demo { // void show1(){} voidshow2(){} } class DemoB extends Demo { // void show1(){} voidshow3(){} } 什么时候定义继承呢？ 当类与类之间存在着所属关系的时候，就定义继承。xxx是yyy中的一种。 xxx extends yyy 所属关系： is a 关系。 */ /* class A { void show() { System.out.println("a"); } } class B { void show() { System.out.println("b"); } } class C extends A,B { } new C().show(); */ class Person { Stringname; intage; } class Student extends/*继承*/ Person { // String name; // int age; voidstudy() { System.out.println(name+"...studentstudy.."+age); } } class Worker extends Person { // String name; // int age; voidwork() { System.out.println("workerwork"); } } class ExtendsDemo { publicstatic void main(String[] args) { Students = new Student(); s.name="zhangsan"; s.age= 22; s.study(); } } /* 在子父类中，成员的特点体现。 1，成员变量。 2，成员函数。 3，构造函数。 */ //1，成员变量。 /* 当本类的成员和局部变量同名用this区分。 当子父类中的成员变量同名用super区分父类。 this和super的用法很相似。 this:代表一个本类对象的引用。 super：代表一个父类空间。子类能访问父类是因为持有指向父类的super引用 */ class Fu { privateint num = 4; publicint getNum() { returnnum; } } class Zi extends Fu { privateint num = 5;//变量不存在覆盖一说 voidshow() { System.out.println(this.num+"....."+super.getNum()); } } class ExtendsDemo2 { publicstatic void main(String[] args) { Ziz = new Zi(); z.show(); } } //成员函数。 /* 当子父类中出现成员函数一模一样的情况，会运行子类的函数。 这种现象，称为覆盖操作。这时函数在子父类中的特性。 函数两个特性： 1，重载。同一个类中。overload 2，覆盖。子类中。覆盖也称为重写，覆写。override 覆盖注意事项： 1，子类方法覆盖父类方法时，子类权限必须要大于等于父类的权限。 2，静态只能覆盖静态，或被静态覆盖。 */ class Fu { publicstatic void show() { System.out.println("fushow run"); } } class Zi extends Fu { publicstatic void show() { System.out.println("Zishow run"); } } class ExtendsDemo3 { publicstatic void main(String[] args) { // Zi z = new Zi(); // z.show(); NewPhonep = new NewPhone(); p.show(); p.call(); } } /* 什么时候使用覆盖操作? 当对一个类进行子类的扩展时，子类需要保留父类的功能声明， 但是要定义子类中该功能的特有内容时，就使用覆盖操作完成. */ class honeP { voidcall() {} voidshow() { System.out.println("number"); } } class NewPhone extends Phone { voidshow() { System.out.println("name"); System.out.println("pic"); super.show(); } } 第九天： 继承-子父类中的构造函数-子类的实例化过程 /* 子父类中的构造函数的特点。 在子类构造对象时，发现，访问子类构造函数时，父类也运行了。 为什么呢？ 原因是：在子类的构造函数中第一行有一个默认的隐式语句。 super(); 子类的实例化过程：子类中所有的构造函数默认都会访问父类中的空参数的构造函数。 为什么子类实例化的时候要访问父类中的构造函数呢？ 那是因为子类继承了父类，获取到了父类中内容(属性)，所以在使用父类内容之前， 要先看父类是如何对自己的内容进行初始化的。 所以子类在构造对象时，必须访问父类中的构造函数。 为什么完成这个必须的动作，就在子类的构造函数中加入了super()语句。 如果父类中没有定义空参数构造函数，那么子类的构造函数必须用super明确要调用 父类中哪个构造函数。同时子类构造函数中如果使用this调用了本类构造函数时， 那么super就没有了，因为super和this都只能定义第一行。所以只能有一个。 但是可以保证的是，子类中肯定会有其他的构造函数访问父类的构造函数。 注意：supre语句必须要定义在子类构造函数的第一行。因为父类的初始化动作要先完成。 */ class Fu { intnum ; Fu() { num=10; System.out.println("Afu run"); } Fu(intx) { System.out.println("Bfu run..."+x); } } class Zi extends Fu { intnum; Zi() { //super();//调用的就是父类中的空参数的构造函数。 System.out.println("Czi run"+num); } Zi(intx) { this(); //super(); // super(x); //没有指定参数时，则super()。指定后不执行super() System.out.println("Dzi run "+x); } } class ExtendsDemo4 { publicstatic void main(String[] args) { newZi(6); } } class Demo//extends Object { /* Demo() { super(); return; } */ } classFu { Fu() { super(); show(); return; } voidshow() { System.out.println("fushow"); } } class Zi extends Fu { intnum = 8; Zi() { super(); //-->通过super初始化父类内容时，子类的成员变量并未显示初始化。等super()父类初始化完毕后， //才进行子类的成员变量显示初始化。 System.out.println("zicons run...."+num); return; } voidshow() { System.out.println("zishow..."+num); } } class ExtendsDemo5 { publicstatic void main(String[] args) { Ziz = new Zi(); z.show(); } } /* 一个对象实例化过程： Person p = newPerson(); 1，JVM会读取指定的路径下的Person.class文件，并加载进内存， 并会先加载Person的父类(如果有直接的父类的情况下). 2，在堆内存中的开辟空间，分配地址。 3，并在对象空间中，对对象中的属性进行默认初始化。 4，调用对应的构造函数进行初始化。 5，在构造函数中，第一行会先到调用父类中构造函数进行初始化。 6，父类初始化完毕后，在对子类的属性进行显示初始化。 7，在进行子类构造函数的特定初始化。 8，初始化完毕后，将地址值赋值给引用变量. */ Final关键字： Final可以修饰类，方法，变量 Final修饰的类不可以被继承。 Final修饰的方法不可以被覆盖 Final修饰的变量是一个常量。只能被赋值一次。 内部类只能访问被final修饰的局部变量 //继承弊端：打破了封装性。 /* final关键字： 1，final是一个修饰符，可以修饰类，方法，变量。 2，final修饰的类不可以被继承。 3，final修饰的方法不可以被覆盖。 4，final修饰的变量是一个常量，只能赋值一次。 为什么要用final修饰变量。其实在程序如果一个数据是固定的， 那么直接使用这个数据就可以了，但是这样阅读性差，所以它该数据起个名称。 而且这个变量名称的值不能变化，所以加上final固定。 写法规范：常量所有字母都大写，多个单词，中间用_连接。 */ class Fu { voidmethod() { //调用了底层系统的资源。 } } class Zi extends Fu { publicstatic final double MY_PI = 3.14; staticfinal int x = 7; voidmethod() { // final int x = 9; // x = 9; finalint NUMBER = 9; System.out.println(MY_PI); } } class FinalDemo { publicstatic void main(String[] args) { System.out.println("HelloWorld!"); } } 抽象类： /* 抽象类： 抽象：笼统，模糊，看不懂！不具体。 比如：狼和狗有共性的内容，吼叫，一旦有共性内容就可以向上抽取。但具体吼叫方式不同 这就要在定义共性内容的类中把吼叫定义成抽象方法，狼和狗类继承该类后，就可以覆盖该抽象方法，定义成自己的吼叫方式 特点： 1，方法只有声明没有实现时，该方法就是抽象方法，需要被abstract修饰。 抽象方法必须定义在抽象类中。该类必须也被abstract修饰。 2，抽象类不可以被实例化。为什么？因为调用抽象方法没意义。 3，抽象类必须有其子类覆盖了所有的抽象方法后，该子类才可以实例化。 否则，这个子类还是抽象类。 1，抽象类中有构造函数吗？ 有，用于给子类对象进行初始化。 2，抽象类可以不定义抽象方法吗？ 可以的。但是很少见，目的就是不让该类创建对象。AWT的适配器对象就是这种类。 通常这个类中的方法有方法体，但是却没有内容。 abstract class Demo { void show1() {} void show2() {} } 3，抽象关键字不可以和那些关键字共存? private 不行：象方法是要进行覆盖操作的，private修饰后把方法隐藏起来就不能进行覆盖操作 static不行：静态方法可以被类名直接调用，调用没有意义。抽象类不能创建对象是因为调用方法没有意义 final 不行：抽象方法是要进行覆盖操作的，而final修饰的方法是不能被覆盖的，水火不相容 4，抽象类和一般类的异同点。 相同点： 抽象类和一般类都是用来描述事物的，都在内部定了成员。 不同： 1，一般类有足够的信息描述事物。 抽象类描述事物的信息有可能不足。 2，一般类中不能定义抽象方法，只能定非抽象方法。 抽象类中可定义抽象方法，同时也可以定义非抽象方法。 3，一般类可以被实例化。 抽象类不可以被实例化。 5，抽象类一定是个父类吗？ 是的。因为需要子类覆盖其方法后才可以对子类实例化。 */ abstract class Demo { abstract/*抽象*/ void show(); } /* class DemoA extendsDemo { void show() { System.out.println("demoashow"); } } class DemoB extendsDemo { void show() { System.out.println("demobshow"); } } */ abstract class 犬科 { abstractvoid 吼叫(); } class 狗 extends 犬科 { void吼叫() { System.out.println("汪汪"); } } class 狼 extends 犬科 { void吼叫() { System.out.println("嗷嗷"); } } class AbstractDemo { publicstatic void main(String[] args) { System.out.println("HelloWorld!"); } } /* 雇员示例： 需求：公司中程序员有姓名，工号，薪水，工作内容。 项目经理除了有姓名，工号，薪水，还有奖金，工作内容。 对给出需求进行数据建模。 分析： 在这个问题领域中，先找出涉及的对象。 通过名词提炼法。 程序员： 属性：姓名，工号，薪水、 行为：工作。 经理： 属性：姓名，工号，薪水，奖金。 行为：工作。 程序员和经理不存在着直接继承关系， 但是程序员和经理却具有共性内容。 可以进行抽取。因为他们都是公司的雇员 可以将程序员和经理进行抽取.建立体系. */ //描述雇员。 abstract class Employee { privateString name; privateString id; privatedouble pay; Employee(Stringname,String id,double pay) { this.name= name; this.id= id; this.pay= pay; } publicabstract void work(); } //描述程序员。 class Programmer extends Employee { Programmer(Stringname,String id,double pay) { super(name,id,pay); } publicvoid work() { System.out.println("code..."); } } //描述经理。 class Manager extends Employee { privateint bonus; Manager(Stringname,String id,double pay,int bonus) { super(name,id,pay); this.bonus= bonus; } publicvoid work() { System.out.println("manage"); } } class AbstractTest { publicstatic void main(String[] args) { System.out.println("HelloWorld!"); } } class Person { privateString name; privateint age; Person(Stringname,int age) { this.name= name; this.age= age; } publicString getName() { returnname; } publicvoid setName(String name) { this.name= name; } } class Student extends Person { Student(Stringname,int age) { super(name,age); } } class Worker extends Person { Worker(Stringname,int age) { super(name,age); } } 接口： /* abstract classAbsDemo { abstract void show1(); abstract void show2(); } 当一个抽象类中的方法都是抽象的时候，这时可以将该抽象类用 另一种形式定义和表示，就是接口 interface。 */ //定义接口使用的关键字不是class，是interface. /* 对于接口当中常见的成员：而且这些成员都有固定的修饰符。 1，全局常量: public static final 2，抽象方法。public abstract 由此得出结论，接口中的成员都是公共的权限. 接口中可以省略固定修饰符，但阅读性差，接口中的方法是要进行覆盖的，必须拥有最高权限，因此写上阅读性强些 如果把全局常量的修饰符public static final去掉，会误以为是变量，阅读性极差。 */ interface Demo { publicstatic final int NUM = 4; publicabstract void show1(); publicabstract void show2(); } //类与类之间是继承关系，类与接口直接是实现关系。 /* 接口不可以实例化。 只能由实现了接口的子类并覆盖了接口中所有的抽象方法后，该子类才可以实例化。 否则，这个子类就是一个抽象类。 */ class DemoImpl implements /*实现*/Demo { publicvoid show1() {} publicvoid show2() { } } /* 在java中不直接支持多继承，因为会出现调用的不确定性。 所以java将多继承机制进行改良，在java中变成了多实现。 一个类可以实现多个接口。 */ interface A { publicvoid show(); } interface Z { publicint add(int a,int b); } class Test implements A,Z//多实现 { publicint add(int a,int b) { returna+b+3; } /**/ publicvoid show(){} } /* 一个类在继承另一个类的同时，还可以实现多个接口。 */ class Q { publicvoid method() {} } abstract class Test2 extends Q implementsA,Z { } /* 接口的出现避免了单继承的局限性。 */ interface CC { voidshow(); } interface MM { voidmethod(); } interface QQ extends CC,MM//接口与接口之间是继承关系，而且接口可以多继承。 { voidfunction(); } class WW implements QQ { //覆盖3个方法。 publicvoid show(){} publicvoid method(){} publicvoid function(){} } class InterfaceDemo { publicstatic void main(String[] args) { Testt = new Test(); t.show();//多实现不会出现调用的不确定性 // DemoImpl d = new DemoImpl(); // System.out.println(d.NUM); // System.out.println(DemoImpl.NUM); // System.out.println(Demo.NUM); } } /* 抽象类和接口的异同点： 相同点： 都是不断向上抽取而来的。 不同点： 1，抽象类需要被继承，而且只能单继承。 接口需要被实现，而且可以多实现。 2，抽象类中可以定义抽象方法和非抽象方法，子类继承后，可以直接使用非抽象方法。 接口中只能定义抽象方法，必须由子类去实现。 3，抽象类的继承，是is a关系，在定义该体系的基本共性内容。 接口的实现是 like a 关系，在定义体系额外功能。 犬按功能分：有导盲犬，搜爆犬。 abstract class 犬 { abstractvoid 吼叫(); } //abstract class 导盲 interface 导盲 { abstractvoid 导盲(); } class 导盲犬 extends 犬 implements 导盲 { publicvoid 吼叫() { } publicvoid 导盲(){} } //在不同的问题领域中，有不同的分析方式。 学员： 学习。 抽烟学员 烟民。 */ class InterfaceDemo { publicstatic void main(String[] args) { System.out.println("HelloWorld!"); } }