java基础2(43页).doc

《java基础2(43页).doc》由会员分享，可在线阅读，更多相关《java基础2(43页).doc（44页珍藏版）》请在淘文阁 - 分享文档赚钱的网站上搜索。

1、-Java基础二1、方法：修饰符 返回值类型 方法的名称(形参列表);方法体Test5.javapublic class Test5public static void main(String args)/ 求（1,1000）区间内的偶数和。printSum(1,100);printSum(1,10000);printSum(25,500);static void printSum(int start,int end)int sum = 0;for(int i=start;iend;i+)if(i%2=0)sum+=i;/sum = sum + i;System.out.println(sum

2、(+start+,+end+)=+sum);注意：该方法是直接将求得的结果直接进行显示输出。有时候是这样的，调用者，求的结果之后，对结果可能有不同的操作。这时我们上面的程序就无法满足了。上面的方法是不需要返回值的，但是方法定义时需要返回值的类型，我们返回什么呢？返回void，void在java中就是上面都不返回，只是为了满足方法的定义。Test5.javapublic class Test5public static void main(String args)/ 求（1,1000）区间内的偶数和。printSum(1,100);printSum(1,10000);printSum(25,50

3、0);int sum = getSum(300,500);System.out.println(sum);System.out.println(sum%3)=0);static int getSum(int start , int end)int sum = 0;for(int i=start;iend;i+)if(i%2=0)sum+=i;return sum;当方法返回值不是void时，就需要借助return关键字进行数据的返回。2、方法的调用：1）非静态方法：Test6.javapublic class Test6public static void main(String args)s

4、how(12);int show(int value)System.out.println(value=+value); 在静态的方法的上面文环境中无法掉用非静态方法。怎么样才能调用呢个？-| 将非静态方法改为静态方法。-| 通过对象来访问方法：Test6.javapublic class Test6public static void main(String args)Test6 t6 = new Test6();t6.show(12);int show(int value)System.out.println(value=+value);return value+10; 2）静态方法的调用

5、：1） 如果两个静态方法在同一个类的内部，一个调用两一个，可以直接写方法的名字。2） 如果两个方法不在同一个类的内部，需要类名加“。”加方法名来访问。public class Test6public static void main(String args)Test6 t6 = new Test6();t6.show(12);print();Test6.print();int show(int value)System.out.println(value=+value);return value+10; static void print()System.out.print(哈哈，我是好人。)

6、;3、属性的默认初始化：数值型默认为0，boolean默认为false，字符型默认为“ ”，引用型默认为null。Person.javapublic class PersonString name;String sex;int age;String address;public static void main(String args)/new Person(李向武).eat(new Baozi();Person p;p = new Person(); System.out.println(p.age);/oSystem.out.println(p.name);/null4、封装：1）将一段业

7、务逻辑，即功能、算法；通过方法来实现，叫封装；2）将具有相同功能和属性的一类事物通过class关键字定义到之间叫封装；3）在描述一类事物时：将其属性私有化（private修饰），通过相应的getter、setter方法对属性进行读写操作，就叫封装，这样做是安全的。Person.javapublic class Personprivate String name;private String sex;private int age;private String address;/setterpublic void setName(String n)name = n;public void set

8、Sex(String s)sex = s;public void setAge(int a)age = a;public void setAddress(String ar)address = ar;/getterpublic String getName()retrun name;public String getSex()return sex;public int getAge()return age;public String getAddress()return address;5、类、对象、类和对象之间的关系1）类：就是一种抽象的概念，如何来抽象的？具有相同功能和相同属性的一类事物。

9、类是对象的集合。2）对象（就是具体事物）：对象的构建应该以类为模板来定义。也就是实例化。对象就是类的一个具体的体现。3）类和对象的关系：类是对象的抽象，是对象的集合；对象是类的一个具体体现，也就是一个具体实例，也就是类中的一个子集。对象必须以类为模板来构建（实例化）。6、无参的构造方法：构造方法的方法名要类名完全一样，不需要返回值类型。Person.javapublic class Personprivate String name;private String sex;private int age;private String address;/setterpublic void setN

10、ame(String n)name = n;public void setSex(String s)sex = s;public void setAge(int a)age = a;public void setAddress(String ar)address = ar;/getterpublic String getName()return name;public String getSex()return sex;public int getAge()return age;public String getAddress()return address;public static voi

11、d main(String args)/调用构造方法就是实例化对象，Person whz = null;/whz = new Person(王忠豪,男,23,湖南邵阳);whz = new Person();编译：javac Person.java会生成一个class：在Person.class文件里。因为Person.class是字节码文件，我们编程人员无法正常识别。但是我们可以借助java的反编译工具：javap.exe来反编译Person.class中的Person类。反编译Person类：javap Person通过反编译的结果和我们自己编写的源程序进行对比，得出java的虚拟机会自动

12、给我们的类添加一个无参的构造方法（当我们没有写构造方法时）。Person.javapublic class Personprivate String name;private String sex;private int age;private String address;/setterpublic void setName(String n)name = n;public void setSex(String s)sex = s;public void setAge(int a)age = a;public void setAddress(String ar)address = ar;/g

13、etterpublic String getName()return name;public String getSex()return sex;public int getAge()return age;public String getAddress()return address;public Person(String n,String s,int a, String ar)name = n;sex = s;age = a;address = ar;public void eat(Baozi bz)System.out.println(name+在吃+bz+,他今年+age+岁！);p

14、ublic static void main(String args)/调用构造方法就是实例化对象，Person whz = null;whz = new Person(王忠豪,男,23,湖南邵阳);/new Person();/报错了。编译：javac Person.java会生成一个Person类，保存在Person.class的文件中。反编译Person类：javap Person通过反编译的结果和我们自己编写的源文件进行比较，得出：当我们自己受到写了构造方法时，系统不再会给我们的类添加无参的构造方法了。也就意味着，编译器在编译源文件时，是先检查该文件是否有构造方法，如果有，虚拟机就不会

15、给添加构造方法，如果没有才添加构造方法，且这个添加的构造方法是没有参数，没有方法的具体实现的。7、方法的重载，动态绑定。Test.javaclass Teststatic int addIntWithInt(int a, int b)int result = 0;result = a + b;return result;static float addIntWithFloat(int a, float b)float result = 0.0f;result = a + b;return result;static double addDoubleWithDouble(double a, do

16、uble b)double result = 0.0;result = a + b;return result;public static void main(String args)System.out.println(addIntWithInt(1,2);System.out.println(addIntWithFloat(1,3.0f); 通过上面的程序得出：方法的可读性虽然很高，但只是针对我们编程人员来说罢了。因为方法的名字里有很多专业术语，非专业人员无法正常使用以上方法。所以不好，就像计算器一样，加运算永远只有一个“+”操作，没有多个，这个使用会很简便。Test.javaclass

17、Teststatic int add(int a, int b)int result = 0;result = a + b;return result;static float add(int a, float b)float result = 0.0f;result = a + b;return result;static double add(double a, double b)double result = 0.0;result = a + b;return result;public static void main(String args)System.out.println(ad

18、d(1,2);System.out.println(add(1,3.0f);System.out.println(add(1.1,3.0); 通过上面的程序：在一个类的内部可以有相同名字的方法存在。Test.javaclass Teststatic int add(int a, int b)int result = 0;result = a + b;return result;static float add(int a, float b)float result = 0.0f;result = a + b;return result;static float add(float a, int

19、 b)float result = 0.0f;result = a + b;return result;static double add(double a, double b)double result = 0.0;result = a + b;return result;static void add(double b, double c)double result = 0.0;result = c + b;/return result;public static void main(String args)System.out.println(add(1,2);System.out.pr

20、intln(add(1,3.0f);System.out.println(add(1.1,3.0); 通过上面的程序说明：在一个类的内部方法名可以相同，但是参数的个数、或者类型不能相同，如果个数相同，但是排列的顺序不能相同。这样做是允许的，同名的方法此时不会冲突。这种情况就叫方法的重载。方法重载：1） 同名的方法要在同一个类的内部；2） 但是方法接收的参数的个数不等，或者类型不同，如果个数相同，但是要保证排列的顺序不同。3） 如果两个方法除返回值的类型不同之外，这两个方法就被认为是重复定义，说明方法的返回值类型的不同，不能作为方法重载的依据。动态绑定：如果方法重载了，方法的调用是由调用者所传递

21、的参数来决定的。给其什么样的参数，java虚拟机会自己选择所要调用的方法。8、方法的调用本质1、作用域：就是变量或者方法的作用范围，或者叫可以使用的范围，还叫可视范围。Test2.javaclass Test2void print()System.out.println(非静态的方法print被调用。);public static void main(String args)int i = 9;System.out.println(main函数中定义的i=+i);/在方法内部定义的“”叫也代码块，具体叫普通代码块。int i = 10;System.out.println(在普通代码块中定义的

22、i=+i); 说明：在main函数中的定义的变量在整个main函数的方法体内都可使用，也就是说该变量的作用域是整个main函数的函数体。即使main函数内有普通代码块。这时我们不能在定义重复的变量了。Test2.javaclass Test2public static void main(String args)int i = 9;System.out.println(main函数中定义的i=+i);/在方法内部定义的“”叫也代码块，具体叫普通代码块。int j = 10;System.out.println(在普通代码块中定义的i=+j);System.out.println(在普通代码块中

23、定义的i=+j); 说明：普通代码块中定义的变量的作用范围就在普通代码块的内部，出了普通代码块，该变量就无法识别了。Test2.javaclass Test2int i = 0;void print()System.out.println(非静态的方法print被调用。+i);public static void main(String args)new Test2().print(); 属性作用域：是整个类的内部。Test2.javaclass Test2int i = 0;void print()System.out.println(非静态的方法print被调用。+i);int i = 1

24、2;System.out.println(非静态的方法print被调用。+i);public static void main(String args)new Test2().print(); 说明：属性的作用域是整个类体，也就是说，在类的方法中是可以看到属性的。但是我们发现在局部作用域中定义与属性同名的变量没有发生冲突。为什么呢？因为局部变量在内存的栈中分配空间，而属性是描述具体对象的，每个对象都拥有一个类的属性的副本，而对象是内存的堆中分配的空间，在物理地址上二者不同的。所以没有发生冲突，即没有被重复定义。如果在局部作用域中定义了和属性相同的变量，此时我们知道在该作用域中可以同时看到成员变

25、量和局部变量，但是使用时，用的是局部变量，这一原则叫“就近原则”；Test2.javaclass Test2int i = 0;static int j = 0;void print()System.out.println(非静态的方法print被调用。i=+i);int i = 12;System.out.println(非静态的方法print被调用。i=+i);System.out.println(非静态的方法print被调用。j=+j);public static void main(String args)new Test2().print();/System.out.println(

26、i);System.out.println(j=+j); 说明：在静态的上下文环境中无法访问非静态的（包括变量和方法），但是我们可以在非静态的上下文环境访问静态的（属性和方法）。Test2.javaclass Test2int i = 0; 、static int j = 0;public Test2()i+;j+;System.out.println(i=+i);System.out.println(j=+j);System.out.println(*);public static void main(String args)new Test2();new Test2();new Test2

27、();new Test2(); 说明：非static修饰的属性（成员变量），每个对象都独自拥有一份。彼此之间互不干扰。而static修饰的变量，所有的类成员公有一份。每个对象如果对该变量进行修改，都会影响到其它对象。即Static修饰的变量只定义一次，即只初始化一次。Test2.javaclass Test2int i = 0;static int j = 0;public Test2()public static void main(String args)System.out.println(Test2.j);/System.out.println(Test2.i);/报错System.o

28、ut.println(new Test2().i); 说明：静态的属性和对象没有直接关系。有没有对象，静态的属性都会被初始化。而非静态的，和对象息息相关。没有对象就没有成员变量。从这里开始。变量：1） 局部变量：相对于类来说，在方法或代码块中定义的变量，它的作用域只局限于方法的内部或代码块的内部，出了方法或代码块就无法识别了。这种变量就叫局部变量。局部变量都在栈中分配空间。局部变量一旦出作用域，内存就会被回收。2） 成员变量：在类的内部，方法的外部定义的变量叫成员变量。因为成员变量是构成对象的元素，对象是类的一个成员，所以我们可以叫这样的变量为成员变量。3） 类变量：在类的内部，方法的外部定义

29、的变量，而且要被static修饰。这样的变量就叫类变量。因为这样的变量即使没有对象，它也是存在的。而且所以的对象共有同一份static修饰的变量。它是属于整个类的，而不是数据具体某一个对象的，所以叫它为类变量。9、类的初始化顺序TestInit.javapublic class TestInitB b5 = new B(5);static B b6 = new B(6);public static void main(String args)/new A();/new TestInit();class AB b1 = new B(1);static B b3 = new B(3);A()Sys

30、tem.out.println(A(););B b2 = new B(2);static B b4 = new B(4);class BB(int i)System.out.println(B(+i+););由上面的程序得出：类变量和对象的有无没有直接关系，只要使用到类（java执行类，或者实例化一个该类的对象）变量所在的类，就会执行static语句；如果我们实例化一个类的对象，程序的执行顺序是：static修饰语句（由上往下）非static修饰的语句（由上往下）构造函数。10、类和类之间的关系：关联关系、聚合关系、组合关系1）关联关系：对象和对象之间，一个对象在执行其自身的功能时，需要另一个

31、对象提供支持，那么这两个对象之间的关系就建立了，是什么关系呢？答：关联关系。2）组合关系：多个对象（1,n n无穷大）和一个对象（a对象）之间的关系：多个对象中的任何一个对象都不能缺失，如果缺失任何一个，那么a对象就不健全了，就不能再称为a对象了。比如：人的四肢和人体之间的关系（多对一的关系），多的一方一个都不能少，少一个就不叫人体了。在程序中怎么描述多的和一的关系：多的一方做为一的一方的属性出现。人体 左臂； 右臂； 左腿； 右腿； 头颅； 躯干；这些个缺一不可。3）聚合关系：是一种比组合关系要弱，比关联关系要强的一种关系，就是在组合关系的基础之上，多的一方可以有，也可以没有，但是应该有。教

32、室 屋顶； 四面墙； 门； 黑板； 桌子； 椅子； 投影仪；投影仪相对于教室是可以有，也可以没有的。4）泛化关系：5）继承关系：但是继承关系是完善泛化关系的一种手段11、对象的引用和thisTest8.javapublic class Test8public static void main(String args)Person p = new Person();System.out.println(p=+p);p.print();/Person.print(p)class Personpublic void print()System.out.println(this=+this);通过上面

33、的程序说明：this就是当前类的一个引用，那它指向的是哪一个对象呢？答：首先this只能在方法中使用，而且该方法应该是非静态方法。我们知道非静态的方法要想执行，必须通过对象来调用，或者通过指向该对象的一个引用来掉用。This其实就和调用this所在的方法的引用指向的是同一个对象。此时的this就是那个引用。 Test8.javapublic class Test8public static void main(String args)Person p = new Person(王忠豪,23);System.out.println(p.name);/输出的结果不是我们传递的“王忠豪”class

34、PersonString name;int age;Person(String name,int age)name = name;age = age;上面的程序输出的结果不是我们传递的值“王忠豪”，那就说明我们没有修改成员变量的值。为什么没有修改成功呢？上面程序中的高亮处的本意是：将局部变量name赋值给成员变量name；但是我们知道有一个就近原则起到了作用，高亮处其实是：局部变量name赋值给了局部变量name，成员变量根本没有参与操作。所以没有发生任何改变，依然是默认值null。Test8.javapublic class Test8public static void main(Stri

35、ng args)Person p = new Person(王忠豪,23);System.out.println(p.name);class PersonString name;int age;Person(String name,int age)this.name = name;this.age = age;本程序解决了上面成员发生的问题。是通过this引用解决的，因为this表示当前类的一个引用，那么this.name和this.age就表示成员变量。Test8.javapublic class Test8public static void main(String args)new Pe

36、rson(whz,29);class PersonString name;int age;Person()System.out.println(Person(););Person(String name,int age)this();this.name = name;this.age = age;System.out.println(Person(String,int);); 说明：this();就是调用构造方法。因为没有传参，根据动态绑定原则，会调用无参的构造函数。所以在执行有参的构造之前，先执行了无参的构造方法。this()只能出现在重载的构造函数的第一行语句，其他位置都不可以。第 44 页-