黑马程序员__java语法与面向对象
---------------------- android培训、java培训、期待与您交流！ ----------------------Java语法：
/*需求：定义一个hello world小程序。思路：1，2，步骤：1，通过class关键字定义一个类。将代码都编写到该类中。2，为了保证该的独立运行。在类中定义个主函数。格式public static void main(String[] args)3,保存成一个扩展名为java的文件。4，在dos控制台中通过javac工具对java文件进行编译。5，在通过java命令对生成的class文件进行执行。*/class Demo//定义一个累。{//主函数。public static void main(String[] args){//输出语句。System.out.println("hello haha");}}?/**作者:张三版本：V1.0这个类是用于演示hello world。*/class Demo //这是我的第一个java小程序，//很爽！{/*main函数可以保证该的独立运行。它是程序的入口。它会被JVM所调用。*/public static void main(String[] args){/*System.out.println("hello java");//这是输出语句，可以打印小括号中的内容。System.out.println("hello world");//？？？？？*/System.out.println("hello java")System.out.println("hello world");}}/*/*床前明月光*/疑是地上霜*/class OperateDemo {public static void main(String[] args) {//int x = 4270;//x = x /1000 * 1000;//System.out.println(-1%5);int a = 3,b;//a++; //--> a = a+ 1;b = ++a;System.out.println("a="+a);//字符串数据和任何数据使用+都是相连接，最终都会变成字符串。//System.out.println("5+5"+(5+5));//"5+5=55"/*转义字符：通过\ 来转变后面字母或者符号的含义。\n:换行。\b:退格。相当于backspace。\r:按下回车键。window系统，回车符是由两个字符来表示\r\n.\t:制表符。相当于tab键。*/System.out.println("hello \t world");//System.out.println("hello java");System.out.println("\\hello\");char ch = '\'';char c = 'a';}}?class OperateDemo2 {public static void main(String[] args) {int x = 7;//逻辑运算符用于连接boolean类型的表达式。//x>3 & x<6 = true & true = true;/*true & true = true;true & false = false;false & true = false;false & false = false;& : 只要两边的boolean表达式结果，有一个为false。那么结果就是false。只有两边都为true，结果为true。*//*true | true = true;true | false = true;false | true = true;false | false = false;| : 两边只要有一个为true，结果为true。只有两边都有false，结果为false。*//*^ : 异或；就是和|有点不一样。当true ^ true = false;true ^ true = false;true ^ false = true;false ^ true = true;false ^ false = false;^ : 两边相同结果是false。两边不同结果是true。*//*!!true*/int a = 2;//a>3 && a<6;/*&和&&的特点：&:无论左边是true是false。右边都运算。&&:当左边为false时，右边不运算。|：两边都参与运算。||：当左边为true。右边不运算。*/System.out.println(false ^ false);System.out.println(~6);int n = 3,m = 8;System.out.println("n="+n+",m="+m);//1,通过第三方变量。/*int temp;temp = n;n = m;m = temp;*///2不用第三方变量。//11 = 3 + 8;//3 = 11 - 8;//8 = 11 - 3;/*n = n + m;//如果n和m的值非常大，容易超出int范围。m = n - m;n = n - m;*/n = n ^ m;m = n ^ m;//(n^m)^m;n = n ^ m;//n ^ (n ^ m)System.out.println("n="+n+",m="+m);}}?
{public static void main(String[] args) {//System.out.println(Integer.toBinaryString(60));//System.out.println(Integer.toHexString(60));int num = 26;//获取60的最低4位，通过&15;int n1 = num & 15;System.out.println(n1>9?(char)(n1-10+'A'):n1);//要获取下一组四位，将60右移4位。int temp = num >>> 4;//对temp的值进行最低四位的获取。int n2 = temp & 15;System.out.println(n2>9?(char)(n2-10+'A'):n2);/*0-9 'A' 'B' 'C' 'D' 'E' 'F'65 66 6710 11 12 13 14 1512 - 10 = 2 + 'A' = (char)67;*/int x = 1,y;y = (x>1)?'a':200;System.out.println("y="+y);}}???class IfDemo {public static void main(String[] args) {int x = 1;if(x>1){System.out.println("yes");}else{System.out.println("a");}/*if else 结构 简写格式： 变量 = (条件表达式)?表达式1：表达式2；三元运算符：好处：可以简化if else代码。弊端：因为是一个运算符，所以运算完必须要有一个结果。*/int a = 9,b;b = (a>1)?100:200;if(a>1)b = 100;elseb = 200;int n = 3;if(n>1)System.out.println("a");else if(n>2)System.out.println("b");else if(n>3)System.out.println("c");elseSystem.out.println("d");/*if(n>1)System.out.println("a");if(n>2)System.out.println("b");if(n>3)System.out.println("c");elseSystem.out.println("d");*/System.out.println("over");}}?class SwitchTest{public static void main(String[] args) {//需求2：根据用于指定月份，打印该月份所属的季节。//3,4,5 春季 6,7,8 夏季 9,10,11 秋季 12, 1, 2 冬季int x = 4;switch(x){case 3:case 4:case 5:System.out.println(x+"春季");break;case 6:case 7:case 8:System.out.println(x+"夏季");break;case 9:case 10:case 11:System.out.println(x+"秋季");break;case 12:case 1:case 2:System.out.println(x+"冬季");break;default:System.out.println("nono");}/*if和switch语句很像。具体什么场景下，应用哪个语句呢？如果判断的具体数值不多，而是符合byte short int char这四种类型。虽然两个语句都可以使用，建议使用swtich语句。因为效率稍高。其他情况：对区间判断，对结果为boolean类型判断，使用if，if的使用范围更广。*/System.out.println("Hello World!");}}?class WhileDemo {public static void main(String[] args){/*定义初始化表达式；while(条件表达式){循环体(执行语句);}int x = 1;while(x<3){System.out.println("x="+x);x++;}int x = 1;do{System.out.println("do : x="+x);x++;}while (x<3);*/int y = 1;while(y<3){System.out.println("y="+y);y++;}/*while:先判断条件，只有条件满足才执行循环体。do while: 先执行循环体，在判断条件，条件满足，再继续执行循环体。简单一句话：do while：无论条件是否满足，循环体至少执行一次。*/}}?class ForDemo {public static void main(String[] args) {/*for(初始化表达式；循环条件表达式；循环后的操作表达式){执行语句；}*/for(int x = 0; x<3 ; x++){System.out.println("x="+x);}//System.out.println("x===="+x);int y=0;while(y<3){System.out.println("y="+y);y++;}System.out.println("y===="+y);/*1,变量有自己的作用域。对于for来讲：如果将用于控制循环的增量定义在for语句中。那么该变量只在for语句内有效。for语句执行完毕。该变量在内存中被释放。2，for和while可以进行互换。如果需要定义循环增量。用for更为合适。总结：什么时候使用循环结构？当要对某些语句执行很多次时，就使用循环结构。*/}}?/*1,获取1~10的和，并打印。*/class ForTest2{public static void main(String[] args) {/*//1,定义变量用于存储不断变化的和。int sum = 0;//2，定义变量，记录住不断变化的被加的数。int x = 1;//3，定义循环，重复加法的过程。while(x<=10){sum = sum + x;x++;}System.out.println("sum="+sum);*//*循环注意：一定要明确哪些语句需要参与循环，哪些不需要。*//* 0+11+2 3+3 6+4 *///用for来体现。int sum = 0;for(int x=0; x<=10; x++){sum += x;}System.out.println("for sum = "+sum);/*其实这就是累加思想。原理：通过变量记录住每次变化的结果。通过循环的形式。进行累加动作。*/}}??/*2,1~100之间 7的倍数的个数。并打印。思路：1，先对1~100进行循环(遍历)通过循环的形式。2，在遍历的过程中，定义条件。只对7的倍数进行操作。3，因为7的倍数不确定，只要符合条件，就通过一个变量来记录住这个变化的次数。步骤：1，定义循环语句，选择for语句。2，在循环中定义判断。只要是7的倍数即可。使用if语句。条件：7的倍数 x%7==0；3，定义变量，该变量随着7的倍数的出现而自增。*/class ForTest3{public static void main(String[] args) {int count = 0;for(int x=1; x<=100; x++){if(x%7==0)//System.out.println("x="+x);count++;}System.out.println("count="+count);/*计数器思想。通过一个变量记录住数据的状态变化。也许通过循环完成。*/}}?class OtherDemo {public static void main(String[] args) {//break：w:for(int x=0; x<3; x++){for(int y=0; y<4; y++){System.out.println("x="+x);break w;}}//continue:只能作用于循环结构。继续循环。特点：结束本次循环，继续下一次循环。for(int x=1; x<=10; x++){if(x%2==1)continue;System.out.println("x="+x);}w:for(int x=0; x<3; x++){for(int y=0; y<4; y++){System.out.println("x="+x);continue w;}}/*记住：1，break和continue语句作用的范围。2，break和continue单独存在时，下面可以有任何语句。因为都执行不到。*///break;//continue;}}???class FunctionDemo {public static void main(String[] args) {/*int x = 4;System.out.println(x*3+5);x = 6;System.out.println(x*3+5);*///int y = 4*3+5;//int z = 6*3+5;//int x = getResult(4);//System.out.println("x="+x);//int y = getResult(6);getResult(5);}//发现以上的运算，因为获取不同数据的运算结果，代码出现了重复。//为了提高代码的复用性。对代码进行抽取。//将这个部分定义成一个独立的功能。方便与日后使用。//java中对功能的定义是通过函数的形式来体现的。//需要定义功能，完成一个整数的*3+5的运算，//1,先明确函数定义的格式。/*修饰符 返回值类型 函数名(参数类型 形式参数1，参数类型 形式参数2，){执行语句;return 返回值;}//当函数运算后，没有具体的返回值时，这是返回值类型用一个特殊的关键字来标识。//该关键字就是void。void:代表的是函数没有具体返回值的情况。//当函数的返回值类型是void时，函数中的return语句可以省略不写。*/public static void getResult(int num){System.out.println(num * 3 + 5);return;//可以省略}}?class FunctionDemo2 {public static void main(String[] args) {/*int sum = getSum(4,6);System.out.println("sum="+sum);sum = getSum(2,7);System.out.println("sum="+sum);*///get(4,5);int x = getSum(4,4);int y = getSum(7,9);int num = getMax(x,y);}/*这个功能定义思想有问题，为什么呢？因为只为完成加法运算，至于是否要对和进行打印操作，那是调用者的事，不要在该功能中完成。public static void get(int a,int b){System.out.println(a+b);return ;}*//*如何定义一个函数呢？1，既然函数是一个独立的功能，那么该功能的运算结果是什么先明确因为这是在明确函数的返回值类型。2，在明确在定义该功能的过程中是否需要未知的内容参与运算。因为是在明确函数的参数列表（参数的类型和参数的个数）。*///需求：定义一个功能。完成3+4的运算。并将结果返回给调用者。/*1，明确功能的结果：是一个整数的和。2，在实现该功能的过程中是否有未知内容参与运算，没有。其实这两个功能就是在明确函数的定义。1，是在明确函数的返回值类型。2，明确函数的参数列表( 参数的类型和参数的个数)。public static int getSum(){return 3+4;}*//*以上这个函数的功能，结果是固定的，毫无扩展性而言。为了方便用户需求。由用户来指定加数和被加数。这样，功能才有意义。思路：1，功能结果是一个和。返回值类型是int。2，有未知内容参与运算。有两个。这个两个未知内容的类型都是int。*/public static int getSum(int x,int y){return x+y;}/*需求：判断两个数是否相同。思路：1，明确功能的结果：结果是：boolean 。2，功能是否有未知内容参与运算。有，两个整数。*/public static boolean compare(int a,int b){/*if(a==b)return true;//elsereturn false;*///return (a==b)?true:false;return a==b;}/*需求：定义功能，对两个数进行比较。获取较大的数。*/public static int getMax(int a,int b){/*if(a>b)return a;elsereturn b;*/return (a>b)?a:b;}}??/*什么时候用重载？当定义的功能相同，但参与运算的未知内容不同。那么，这时就定义一个函数名称以表示起功能，方便阅读，而通过参数列表的不同来区分多个同名函数。*/class FunctionOverload {public static void main(String[] args) {//add(4,5);//add(4,5,6);print99();}public static void print99(int num){for(int x=1; x<=num; x++){for(int y=1; y<=x; y++){System.out.print(y+"*"+x+"="+y*x+"\t");}System.out.println();}}//打印99乘法表public static void print99(){print99(9);}//定义一个加法运算，获取两个整数的和。public static int add(int x,int y){return x+y;}//定义一个加法，获取三个整数的和。public static int add(int x,int y,int z){return add(x,y)+z;}}/*void show(int a,char b,double c){}a.void show(int x,char y,double z){}//没有，因为和原函数一样。b.int show(int a,double c,char b){}//重载，因为参数类型不同。注意：重载和返回值类型没关系。c.void show(int a,double c,char b){}//重载，因为参数类型不同。注意：重载和返回值类型没关系。d.boolean show(int c,char b){}//重载了，因为参数个数不同。e.void show(double c){}//重载了，因为参数个数不同。f.double show(int x,char y,double z){}//没有，这个函数不可以和给定函数同时存在与一个类中。*/??/**/class ArrayDemo {public static void main(String[] args) {//元素类型[] 数组名 = new 元素类型[元素个数或数组长度];//需求：想定义一个可以存储3个整数的容器。int[] x = new int[3];//打印数组中角标为0的元素的值。System.out.println(x[1]);}}??class ArrayDemo2{public static void main(String[] args) {//int[] arr = new int[2];//int arr[] = new int[2];//int[] arr = new int[]{3,1,6,5,4};//int[] arr = {3,1,6,5,4};//System.out.println(arr[2]);//int[] arr = new int[5];//arr[0] = 90;//arr[1] = 80;int[] arr = new int[3];arr = null;System.out.println(arr[1]);//ArrayIndexOutOfBoundsException: 3:操作数组时，访问到了数组中不存在的角标。//NullPointerException:空指针异常：当引用没有任何指向值为null的情况，该引用还在用于操作实体。}}????????/*给定一个数组{5,1,6,4,2,8,9}。1，获取数组中的最大值，以及最小值。*/class ArrayTest {/*获取数组中的最大值。思路：1，获取最值需要进行比较。每一次比较都会有一个较大的值。因为该值不确定。通过一个变量进行临储。2，让数组中的每一个元素都和这个变量中的值进行比较。如果大于了变量中的值，就用该该变量记录较大值。3，当所有的元素都比较完成，那么该变量中存储的就是数组中的最大值了。步骤：1，定义变量。初始化为数组中任意一个元素即可。2，通过循环语句对数组进行遍历。3，在变量过程中定义判断条件，如果遍历到的元素比变量中的元素大，就赋值给该变量；需要定义一个功能来完成。以便提高复用性。1，明确结果，数组中的最大元素 int。、2，未知内容：一个数组。int[]*/public static int getMax(int[] arr){int max = arr[0];for(int x=1; x<arr.length; x++){if(arr[x]>max)max = arr[x];}return max;}/*获取最大值的另一种方式。可不可以将临时变量初始化为0呢？可以。这种方式，其实是在初始化为数组中任意一个角标。*/public static int getMax_2(int[] arr){int max = 0;for(int x=1; x<arr.length; x++){if(arr[x]>arr[max])max = x;}return arr[max];}/*获取最小值。*/public static int getMin(int[] arr){int min = 0;for(int x=1; x<arr.length; x++){if(arr[x]<arr[min])min = x;}return arr[min];}//获取double类型数组的最大值。因为功能一致，所以定义相同函数名称。以重载形式存在。/*public static double getMax(double[] arr){}*/public static void main(String[] args){int[] arr ={5,1,6,4,2,8,9};int max = getMax_2(arr);int min = getMin(arr);System.out.println("max="+max);System.out.println("min="+min);//boolean[] ar = new boolean[3];//System.out.println(ar[1]);}}?面向对象：//面向对象：三个特征：封装，继承，多态。//以后开发：其实就是找对象使用。没有对象，就创建一个对象。//找对象，建立对象，使用对象。维护对象的关系。/*类和对象的关系。现实生活中的对象：张三 李四。想要描述：提取对象中共性内容。对具体的抽象。描述时：这些对象的共性有：姓名，年龄，性别，学习java功能。映射到java中，描述就是class定义的类。具体对象就是对应java在堆内存中用new建立实体。类就是：对现实生活中事物的描述。对象：就是这类事物，实实在在存在个体。*///需求：描述汽车(颜色，轮胎数)。描述事物其实就是在描述事物的属性和行为。//属性对应是类中变量，行为对应的类中的函数(方法)。//其实定义类，就是在描述事物，就是在定义属性和行为。属性和行为共同成为类中的成员(成员变量和成员方法)。/*成员变量和局部变量。作用范围。成员变量作用于整个类中。局部变量变量作用于函数中，或者语句中。在内存中的位置：成员变量：在堆内存中，因为对象的存在，才在内存中存在。局部变量：存在栈内存中。*/class Car{//描述颜色String color = "红色";//描述轮胎数int num = 4;//运行行为。void run(){System.out.println(color+".."+num);}}class CarDemo{public static void main(String[] args) {//生产汽车。在java中通过new操作符来完成。//其实就是在堆内存产生一个实体。//Car c = new Car();//c就是一个类类型变量。记住：类类型变量指向对象。//需求：将已有车的颜色改成蓝色。指挥该对象做使用。在java指挥方式是：对象.对象成员//c.color = "blue";//c.run();//Car c1 = new Car();//c1.run();//red 4;//Car c = new Car();//c.num = 5;/*new Car().num = 5;new Car().color = "blue";new Car().run();Car c = new Car();c.run();c.num = 4;new Car().run();*///匿名对象使用方式一：当对对象的方法只调用一次时，可以用匿名对象来完成，这样写比较简化。//如果对一个对象进行多个成员调用，必须给这个对象起个名字。//匿名对象使用方式二：可以将匿名对象作为实际参数进行传递。Car q = new Car();show(q);//show(new Car());}//需求：汽车修配厂。对汽车进行改装，将来的车够改成黑车，三个轮胎。public static void show(Car c){c.num = 3;c.color = "black";c.run();}}?/*private :私有，权限修饰符：用于修饰类中的成员(成员变量，成员函数)。私有只在本类中有效。将age私有化以后，类以外即使建立了对象也不能直接访问。但是人应该有年龄，就需要在Person类中提供对应访问age的方式。注意：私有仅仅是封装的一种表现形式。之所以对外提供访问方式，就因为可以在访问方式中加入逻辑判断等语句。对访问的数据进行操作。提高代码健壮性。*/class Person{private int age;public void setAge(int a){if(a>0 && a<130){age = a;speak();}elseSystem.out.println("feifa age");}public int getAge(){return age;}private void speak(){System.out.println("age="+age);}}class PersonDemo{public static void main(String[] args){Person p = new Person();//p.age = -20;p.setAge(-40);//p.speak();}}?/*对象一建立就会调用与之对应的构造函数。构造函数的作用：可以用于给对象进行初始化。构造函数的小细节：当一个类中没有定义构造函数时，那么系统会默认给该类加入一个空参数的构造函数。当在类中自定义了构造函数后，默认的构造函数就没有了。构造函数和一般函数在写法上有不同。在运行上也有不同。构造函数是在对象一建立就运行。给对象初始化。而一般方法是对象调用才执行，给是对象添加对象具备的功能。一个对象建立，构造函数只运行一次。而一般方法可以被该对象调用多次。什么时候定义构造函数呢？当分析事物时，该事物存在具备一些特性或者行为，那么将这些内容定义在构造函数中。*/class Person{private String name;private int age;/*构造代码块。作用：给对象进行初始化。对象一建立就运行，而且优先于构造函数执行。和构造函数的区别：构造代码块是给所有对象进行统一初始化，而构造函数是给对应的对象初始化。构造代码快中定义的是不同对象共性的初始化内容。*/{//System.out.println("person code run");cry();}Person(){System.out.println("A: name="+name+",,age="+age);}/**/Person(String n){name = n;System.out.println("B: name="+name+",,age="+age);//cry();}/*public void setName(String n){name = n;}public String getName(){return name;}*/Person(String n,int a){name = n;age = a;System.out.println("C: name="+name+",,age="+age);//cry();}public void cry(){System.out.println("cry......");}}class PersonDemo2{public static void main(String[] args) {Person p1 = new Person();Person p2 = new Person("lisi");//System.out.println(p2.getName());//Person p3 = new Person("wnagu",10);}}?/*this:看上去，是用于区分局部变量和成员变量同名情况。this为什么可以解决这个问题？this到底代表的是什么呢？this：就代表本类的对象，到底代表哪一个呢？this代表它所在函数所属对象的引用。简单说：哪个对象在调用this所在的函数，this就代表哪个对象。this的应用：当定义类中功能时，该函数内部要用到调用该函数的对象时，这时用this来表示这个对象。但凡本类功能内部使用了了本类对象，都用this表示。*/class Person{private String name;private int age;Person(int age){this.age = age;}Person(String name){this.name = name;}Person(String name,int age){this.name = name;this.age = age;}public void speak(){System.out.println("name="+this.name+"...age="+this.age);this.show();}public void show(){System.out.println(this.name);}/*需求：给人定义一个用于比较年龄是否相同的功能。也就是是否是同龄人。*/public boolean compare(Person p){return this.age==p.age;}}class PersonDemo3 {public static void main(String[] args) {Person p1 = new Person(20);Person p2 = new Person(25);boolean b = p1.compare(p2);System.out.println(b);//Person p = new Person("lisi");//Person p1 = new Person("zhangsan");//p.speak();//p1.speak();//p.speak();}}?/*this语句 :用于构造函数之间进行互相调用。this语句只能定义在构造函数的第一行。因为初始化要先执行。*/class Person{private String name;private int age;{System.out.println("code run");}Person(){//this("hah");System.out.println("person run");}Person(String name){//this();this.name =name;}Person(String name,int age){//this(name);//this.name = name;this.age = age;}}class PersonDemo4{public static void main(String[] args) {new Person();//Person p = new Person("lisi",30);//Person p1 = new Person("lisi2",36);}}?/*静态：static。用法：是一个修饰符，用于修饰成员(成员变量，成员函数).当成员被静态修饰后，就多了一个调用方式，除了可以被对象调用外，还可以直接被类名调用。类名.静态成员。static特点：1，随着类的加载而加载。 也就说：静态会随着类的消失而消失。说明它的生命周期最长。2，优先于的对象存在明确一点：静态是先存在。对象是后存在的。3，被所有对象所共享4，可以直接被类名所调用。实例变量和类变量的区别：1，存放位置。类变量随着类的加载而存在于方法区中。实例变量随着对象的建立而存在于堆内存中。2，生命周期：类变量生命周期最长，随着类的消失而消失。实例变量生命周期随着对象的消失而消失。静态使用注意事项：1，静态方法只能访问静态成员。非静态方法既可以访问静态也可以访问非静态。2，静态方法中不可以定义this，super关键字。因为静态优先于对象存在。所以静态方法中不可以出现this。3，主函数是静态的。静态有利有弊利处：对对象的共享数据进行单独空间的存储，节省空间。没有必要每一个对象中都存储一份。可以直接被类名调用。弊端：生命周期过长。 访问出现局限性。(静态虽好，只能访问静态。)*/class Person{String name;//成员变量，实例变量。static String country = "CN";//静态的成员变量，类变量。public static void show(){System.out.println("::::");this.haha();}public void haha(){}}class StaticDemo{public static void main(String[] args) {Person p = new Person();//p.name = "zhangsan";//p.show();//System.out.println(p.country);//System.out.println(Person.country);Person.show();}}?/*public static void main(String[] args) 主函数：是一个特殊的函数。作为程序的入口，可以被jvm调用。主函数的定义：public：代表着该函数访问权限是最大的。static：代表主函数随着类的加载就已经存在了。void：主函数没有具体的返回值。main：不是关键字，但是是一个特殊的单词，可以被jvm识别。（String[] arr）:函数的参数，参数类型是一个数组，该数组中的元素是字符串。字符串类型的数组。主函数是固定格式的：jvm识别。jvm在调用主函数时，传入的是new String[0];*/class MainDemo {public static void main(String[] args)//new String[]{String[] arr = {"hah","hhe","heihei","xixi","hiahia"};MainTest.main(arr);}}//String[] args = new String[3];//String[] args = null;class MainTest{public static void main(String[] args){for(int x=0; x<args.length; x++)System.out.println(args[x]);}}?/*什么使用静态？要从两方面下手：因为静态修饰的内容有成员变量和函数。什么时候定义静态变量(类变量)呢？当对象中出现共享数据时，该数据被静态所修饰。对象中的特有数据要定义成非静态存在于堆内存中。什么时候定义静态函数呢？当功能内部没有访问到肺静态数据(对象的特有数据)，那么该功能可以定义成静态的。*/class Person{String name;static String country = "cn";public static void show(){System.out.println(contry+"haha");}}class {public static void main(String[] args) {Person p = new Person();p.show();//Person .show();}}?/*静态的应用。每一个应用程序中都有共性的功能，可以将这些功能进行抽取，独立封装。以便复用。虽然可以通过建立ArrayTool的对象使用这些工具方法，对数组进行操作。发现了问题：1，对象是用于封装数据的，可是ArrayTool对象并未封装特有数据。2，操作数组的每一个方法都没有用到ArrayTool对象中的特有数据。这时就考虑，让程序更严谨，是不需要对象的。可以将ArrayTool中的方法都定义成static的。直接通过类名调用即可。将方法都静态后，可以方便于使用，但是该类还是可以被其他程序建立对象的。为了更为严谨，强制让该类不能建立对象。可以通过将构造函数私有化完成。接下来，将ArrayTool.class文件发送给其他人，其他人只要将该文件设置到classpath路径下，就可以使用该工具类。但是，很遗憾，该类中到底定义了多少个方法，对方去不清楚。因为该类并没有使用说明书。开始制作程序的说明书。java的说明书通过文档注释来完成。*//**这是一个可以对数组进行操作的工具类，该类中提供了，获取最值，排序等功能。@author 张三@version V1.1*///javadoc -d myhelp -author -version ArrayTool.javapublic class ArrayTool{/**空参数构造函数。*/private ArrayTool(){}/**获取一个整形数组中的最大值。@param arr 接收一个int类型的数组。@return 会返回一个该数组中最大值。*/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];}/**获取一个整形数组中的最小值。@param arr 接收一个int类型的数组。@return 会返回一个该数组中最小值。*/public static int getMin(int[] arr){int min = 0;for(int x=1; x<arr.length; x++){if(arr[x]<arr[min])min = x;}return arr[min];}/**给int数组进行选择排序。@param arr 接收一个int类型的数组。*/public static void selectSort(int[] arr){for (int x=0; x<arr.length-1 ; x++ ){for(int y=x+1; y<arr.length; y++){if(arr[x]>arr[y]){swap(arr,x,y);}}}}/**给int数组进行冒泡排序。@param arr 接收一个int类型的数组。*/public static void bubbleSort(int[] arr){for (int x=0; x<arr.length-1 ; x++ ){for(int y=0; y<arr.length-x-1; y++){if(arr[y]>arr[y+1]){swap(arr,y,y+1);}}}}/**给数组中元素进行位置的置换。@param arr 接收一个int类型的数组。@param a 要置换的位置 @param b 要置换的位置 */private static void swap(int[] arr,int a,int b){int temp = arr[a];arr[a] = arr[b];arr[b] = temp;}/**用于打印数组中的元素。打印形式是：[elemet1, element2, ...]*/public static void printArray(int[] arr){System.out.print("[");for(int x=0; x<arr.length; x++){if(x!=arr.length-1)System.out.print(arr[x]+", ");elseSystem.out.println(arr[x]+"]");}}}/*一个类中默认会有一个空参数的构造函数，这个默认的构造函数的权限和所属类一致。如果类被public修饰，那么默认的构造函数也带public修饰符。如果类没有被public修饰，那么默认的构造函数，也没有public修饰。默认构造构造函数的权限是随着的类的变化而变化的。*//*class Demo{public static void main(String[] args){int[] arr = {3,4,1,8};int max = getMax(arr);System.out.println("max="+max);}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];}}*/?/*静态：static。用法：是一个修饰符，用于修饰成员(成员变量，成员函数).当成员被静态修饰后，就多了一个调用方式，除了可以被对象调用外，还可以直接被类名调用。类名.静态成员。static特点：1，随着类的加载而加载。 也就说：静态会随着类的消失而消失。说明它的生命周期最长。2，优先于的对象存在明确一点：静态是先存在。对象是后存在的。3，被所有对象所共享4，可以直接被类名所调用。实例变量和类变量的区别：1，存放位置。类变量随着类的加载而存在于方法区中。实例变量随着对象的建立而存在于堆内存中。2，生命周期：类变量生命周期最长，随着类的消失而消失。实例变量生命周期随着对象的消失而消失。静态使用注意事项：1，静态方法只能访问静态成员。非静态方法既可以访问静态也可以访问非静态。2，静态方法中不可以定义this，super关键字。因为静态优先于对象存在。所以静态方法中不可以出现this。3，主函数是静态的。静态有利有弊利处：对对象的共享数据进行单独空间的存储，节省空间。没有必要每一个对象中都存储一份。可以直接被类名调用。弊端：生命周期过长。 访问出现局限性。(静态虽好，只能访问静态。)*/class Person{String name;//成员变量，实例变量。static String country = "CN";//静态的成员变量，类变量。public static void show(){System.out.println("::::");this.haha();}public void haha(){}}class StaticDemo{public static void main(String[] args) {Person p = new Person();//p.name = "zhangsan";//p.show();//System.out.println(p.country);//System.out.println(Person.country);Person.show();}}?/*静态代码块。格式：static{静态代码块中的执行语句。}特点：随着类的加载而执行，只执行一次,并优先于主函数。用于给类进行初始化的。*/class StaticCode{int num = 9;StaticCode(){System.out.println("b");}static{System.out.println("a");}{System.out.println("c"+this.num);}StaticCode(int x){System.out.println("d");}public static void show(){System.out.println("show run");}}class StaticCodeDemo {static{//System.out.println("b");}public static void main(String[] args) {new StaticCode(4);//a c d //new StaticCode();//new StaticCode();//System.out.println("over");//StaticCode.show();//StaticCode s = null;//s = new StaticCode();//StaticCode.show();}static{///System.out.println("c");}}//d:\>java0217\day06>java StaticCodeDemo//b c a overclass Person{private Person(){}private String name = "hah";private int age;private static String country = "cn";Person(String name,int age){this.name = name;this.age = age;}{System.out.println(name+".."+age);}public void setName(String name){this.name = name;}public void speak(){System.out.println(this.name+"..."+this.age);}public static void showCountry(){System.out.println("country="+Person.country);Person.method();}public static void method(){System.out.println("method run");}}class PersonDemo{public static void main(String[] args) {Person p = new Person("zhangsan",20);p.setName("lisi");new Person();}}/*Person p = new Person("zhangsan",20);该句话都做了什么事情？1，因为new用到了Person.class.所以会先找到Person.class文件并加载到内存中。2，执行该类中的static代码块，如果有的话，给Person.class类进行初始化。3，在堆内存中开辟空间，分配内存地址。4，在堆内存中建立对象的特有属性。并进行默认初始化。5，对属性进行显示初始化。6，对对象进行构造代码块初始化。7，对对象进行对应的构造函数初始化。8，将内存地址付给栈内存中的p变量。*//*设计模式：解决某一类问题最行之有效的方法。java中23种设计模式：单例设计模式：解决一个类在内存只存在一个对象。想要保证对象唯一。1，为了避免其他程序过多建立该类对象。先禁止其他程序建立该类对象2，还为了让其他程序可以访问到该类对象，只好在本类中，自定义一个对象。3，为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式。这三部怎么用代码体现呢？1，将构造函数私有化。2，在类中创建一个本类对象。3，提供一个方法可以获取到该对象。对于事物该怎么描述，还怎么描述。当需要将该事物的对象保证在内存中唯一时，就将以上的三步加上即可。*/class Single{private Single(){}private static Single s = new Single();public static Single getInstance(){return s;}}class SingleDemo {public static void main(String[] args) {Single s1 = Single.getInstance();Single s2 = Single.getInstance();s1.setNum(23);System.out.println(s2.getNum());//Single s1 = new Single();//Single s2= new Single();//s1.setNum(30);//System.out.println(s2.getNum());//Student s1 = new Student();//s1.setAge(30);////Student s2 = new Student();//s2.setAge(12);Student s1 = Student.getStudent();Student s2 = Student.getStudent();}}class Student{private int age;private static Student s = new Student();private Student(){}public static Student getStudent(){return s;}public void setAge(int age){this.age = age;}public int getAge(){return age;}}?/*这个是先初始化对象。称为：饿汉式。Single类一进内存，就已经创建好了对象。class Single{private static Single s = new Single();private Single(){}public static Single getInstance(){return s;}}*///对象是方法被调用时，才初始化，也叫做对象的延时加载。成为：懒汉式。//Single类进内存，对象还没有存在，只有调用了getInstance方法时，才建立对象。class Single{private static Single s = null;private Single(){}public static Single getInstance(){if(s==null){synchronized(Single.class){if(s==null)s = new Single();}}return s;}}//记录原则：定义单例，建议使用饿汉式。class {public static void main(String[] args) {System.out.println("Hello World!");}}?????/*将学生和工人的共性描述提取出来，单独进行描述，只要让学生和工人与单独描述的这个类有关系，就可以了。继承：1，提高了代码的复用性。2，让类与类之间产生了关系。有了这个关系，才有了多态的特性。注意：千万不要为了获取其他类的功能，简化代码而继承。必须是类与类之间有所属关系才可以继承。所属关系 is a。class C{void demo1(){}}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();聚集：has a聚合:组合：*/class Person{String name;int age;}class Student extends Person{void study(){System.out.println("good study");}}class Worker extends Person{void work(){System.out.println("good work");}}class ExtendsDemo {public static void main(String[] args) {Student s = new Student();s.name = "zhagnsan";}}?/*子父类出现后，类成员的特点：类中成员：1，变量。2，函数。3，构造函数。1,变量如果子类中出现非私有的同名成员变量时，子类要访问本类中的变量，用this子类要访问父类中的同名变量，用super。super的使用和this的使用几乎一致。this代表的是本类对象的引用。super代表的是父类对象的引用。*/class Fu {private int num = 4;public void setNum(int num){this.num =num;}public int getNum(){return this.num;}}class Zi extends Fu{//int num = 5;void show(){System.out.println(num);}}class ExtendsDemo2{public static void main(String[] args) {Zi z = new Zi();z.show();//System.out.println(z.num+"...."+z.num);}}/*2,子父类中的函数。当子类出现和父类一模一样的函数时，当子类对象调用该函数，会运行子类函数的内容。如同父类的函数被覆盖一样。这种情况是函数的另一个特性：重写(覆盖)当子类继承父类，沿袭了父类的功能，到子类中，但是子类虽具备该功能，但是功能的内容却和父类不一致，这时，没有必要定义新功能，而是使用覆盖特殊，保留父类的功能定义，并重写功能内容。覆盖：1，子类覆盖父类，必须保证子类权限大于等于父类权限，才可以覆盖，否则编译失败。2，静态只能覆盖静态。记住大家：重载：只看同名函数的参数列表。重写：子父类方法要一模一样。*/class Fu{void show(){System.out.println("fu show");}void speak(){System.out.println("vb");}}class Zi extends Fu{void speak(){System.out.println("java");}void show(){System.out.println("zi show");}}class ExtendsDemo3 {public static void main(String[] args) {Zi z = new Zi();z.speak();}}class Tel{void show(){System.out.println("number");}}class NewTel extends Tel{void show(){//System.out.println("number");super.show();System.out.println("name");System.out.println("pic");}}?/*3，子父类中的构造函数。在对子类对象进行初始化时，父类的构造函数也会运行，那是因为子类的构造函数默认第一行有一条隐式的语句 super();super():会访问父类中空参数的构造函数。而且子类中所有的构造函数默认第一行都是super();为什么子类一定要访问父类中的构造函数。因为父类中的数据子类可以直接获取。所以子类对象在建立时，需要先查看父类是如何对这些数据进行初始化的。所以子类在对象初始化时，要先访问一下父类中的构造函数。如果要访问父类中指定的构造函数，可以通过手动定义super语句的方式来指定。注意：super语句一定定义在子类构造函数的第一行。子类的实例化过程。结论：子类的所有的构造函数，默认都会访问父类中空参数的构造函数。因为子类每一个构造函数内的第一行都有一句隐式super();当父类中没有空参数的构造函数时，子类必须手动通过super语句形式来指定要访问父类中的构造函数。当然：子类的构造函数第一行也可以手动指定this语句来访问本类中的构造函数。子类中至少会有一个构造函数会访问父类中的构造函数。*/class Fu //extends Object{int num ;Fu(){//super();num= 60;System.out.println("fu run");}Fu(int x){System.out.println("fu ...."+x);}}class Zi extends Fu{Zi(){super(); //super(4);System.out.println("zi run");}Zi(int x){this();//super();//super(3);System.out.println("zi..."+x);}}class ExtendsDemo4{public static void main(String[] args) {Zi z = new Zi(0);System.out.println(z.num);}}/*class Person{private String name;Person(String name){this.name = name;}void show(){}}class Student extends Person{Student(String name){super(name);}void method(){super.show();}}*/?/*final : 最终。作为一个修饰符，1，可以修饰类，函数，变量。2，被final修饰的类不可以被继承。为了避免被继承，被子类复写功能。3，被final修饰的方法不可以被复写。4，被final修饰的变量是一个常量只能赋值一次，既可以修饰成员变量，有可以修饰局部变量。当在描述事物时，一些数据的出现值是固定的，那么这时为了增强阅读性，都给这些值起个名字。方便于阅读。而这个值不需要改变，所以加上final修饰。作为常量：常量的书写规范所有字母都大写，如果由多个单词组成。单词间通过_连接。5，内部类定义在类中的局部位置上是，只能访问该局部被final修饰的局部变量。*/class Demo{final int x = 3;public static final double PI = 3.14;final void show1(){}void show2(){final int y = 4;System.out.println(3.14);}}class SubDemo extends Demo{//void show1(){}}class FinalDemo {public static void main(String[] args) {System.out.println("Hello World!");}}?????/*当多个类中出现相同功能，但是功能主体不同，这是可以进行向上抽取。这时，只抽取功能定义，而不抽取功能主体。抽象：看不懂。抽象类的特点：1，抽象方法一定在抽象类中。2，抽象方法和抽象类都必须被abstract关键字修饰。3，抽象类不可以用new创建对象。因为调用抽象方法没意义。4，抽象类中的抽象方法要被使用，必须由子类复写起所有的抽象方法后，建立子类对象调用。如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象类。抽象类和一般类没有太大的不同。该如何描述事物，就如何描述事物，只不过，该事物出现了一些看不懂的东西。这些不确定的部分，也是该事物的功能，需要明确出现。但是无法定义主体。通过抽象方法来表示。抽象类比一般类多个了抽象函数。就是在类中可以定义抽象方法。抽象类不可以实例化。特殊：抽象类中可以不定义抽象方法，这样做仅仅是不让该类建立对象。练习：abstract 关键字，和哪些关键字不能共存。final：被final修饰的类不能有子类。而被abstract修饰的类一定是一个父类。private: 抽象类中的私有的抽象方法，不被子类所知，就无法被复写。而抽象方法出现的就是需要被复写。static：如果static可以修饰抽象方法，那么连对象都省了，直接类名调用就可以了。可是抽象方法运行没意义。抽象类中是否有构造函数？有，抽象类是一个父类，要给子类提供实例的初始化。*/abstract class Student{abstract final void study();//abstract void study1();void sleep(){System.out.println("躺着");}}/*class ChongCiStudent extends Student{void study(){System.out.println("chongci study");}}class BaseStudent extends Student{void study(){System.out.println("base study");}}class AdvStudent extends Student{void study(){System.out.println("adv study");}}*/class AbstractDemo {public static void main(String[] args) {//new Student();//new BaseStudent().study();}}/*需求：获取一段程序运行的时间。原理：获取程序开始和结束的时间并相减即可。获取时间：System.currentTimeMillis();当代码完成优化后，就可以解决这类问题。这种方式，模版方法设计模式。什么是模版方法呢？在定义功能时，功能的一部分是确定的，但是有一部分是不确定，而确定的部分在使用不确定的部分，那么这时就将不确定的部分暴露出去。由该类的子类去完成。*/abstract class GetTime{public final void getTime(){long start = System.currentTimeMillis();runcode();long end = System.currentTimeMillis();System.out.println("毫秒："+(end-start));}public abstract void runcode();}class SubTime extends GetTime{public void runcode(){for(int x=0; x<4000; x++){System.out.print(x);}}}class TemplateDemo{public static void main(String[] args) {//GetTime gt = new GetTime();SubTime gt = new SubTime();gt.getTime();}}?/*接口：初期理解，可以认为是一个特殊的抽象类当抽象类中的方法都是抽象的，那么该类可以通过接口的形式来表示。class用于定义类interface 用于定义接口。接口定义时，格式特点：1，接口中常见定义：常量，抽象方法。2，接口中的成员都有固定修饰符。常量：public static final方法：public abstract 记住：接口中的成员都是public的。接口：是不可以创建对象的，因为有抽象方法。需要被子类实现，子类对接口中的抽象方法全都覆盖后，子类才可以实例化。否则子类是一个抽象类。接口可以被类多实现，也是对多继承不支持的转换形式。java支持多实现。*/interface Inter{public static final int NUM = 3;public abstract void show();}interface InterA{public abstract void show();}class Demo{public void function(){}}class Test extends Demo implements Inter,InterA{public void show(){}}interface A{void methodA();}interface B //extends A{void methodB();}interface C extends B,A{void methodC();}class D implements C{public void methodA(){}public void methodC(){}public void methodB(){}}class InterfaceDemo {public static void main(String[] args) {Test t = new Test();System.out.println(t.NUM);System.out.println(Test.NUM);System.out.println(Inter.NUM);}}?/*多态：可以理解为事物存在的多种体现形态。人：男人，女人动物：猫，狗。猫 x = new 猫();动物 x = new 猫();1，多态的体现父类的引用指向了自己的子类对象。父类的引用也可以接收自己的子类对象。2，多态的前提必须是类与类之间有关系。要么继承，要么实现。通常还有一个前提：存在覆盖。3，多态的好处多态的出现大大的提高程序的扩展性。4，多态的弊端：提高了扩展性，但是只能使用父类的引用访问父类中的成员。5，多态的应用*//*动物，猫，狗。*/abstract class Animal{abstract void eat();}class Cat extends Animal{public void eat(){System.out.println("吃鱼");}public void catchMouse(){System.out.println("抓老鼠");}}class Dog extends Animal{public void eat(){System.out.println("吃骨头");}public void kanJia(){System.out.println("看家");}}class Pig extends Animal{public void eat(){System.out.println("饲料");}public void gongDi(){System.out.println("拱地");}}//-----------------------------------------class DuoTaiDemo {public static void main(String[] args) {//Cat c = new Cat();//c.eat();//Dog d = new Dog();//d.eat();//Cat c = new Cat();/*Cat c1 = new Cat();function(c1);function(new Dog());function(new Pig());*///Animal c = new Cat();//c.eat();function(new Cat());function(new Dog());function(new Pig());}public static void function(Animal a)//Animal a = new Cat();{a.eat();//a.catchMouse();}/*public static void function(Cat c)//{c.eat();}public static void function(Dog d){d.eat();}public static void function(Pig p){p.eat();}*/}??/*多态：可以理解为事物存在的多种体现形态。人：男人，女人动物：猫，狗。猫 x = new 猫();动物 x = new 猫();1，多态的体现父类的引用指向了自己的子类对象。父类的引用也可以接收自己的子类对象。2，多态的前提必须是类与类之间有关系。要么继承，要么实现。通常还有一个前提：存在覆盖。3，多态的好处多态的出现大大的提高程序的扩展性。4，多态的弊端：虽然提高了扩展性，但是只能使用父类的引用访问父类中的成员。5，多态的应用6，多态的出现代码中的特点(多态使用的注意事项)第二个问题：如何使用子类特有方法。*//*动物，猫，狗。*/class Cat extends Animal{public void eat(){System.out.println("吃鱼");}public void catchMouse(){System.out.println("抓老鼠");}}class Dog extends Animal{public void eat(){System.out.println("吃骨头");}public void kanJia(){System.out.println("看家");}}class Pig extends Animal{public void eat(){System.out.println("饲料");}public void gongDi(){System.out.println("拱地");}}//-----------------------------------------class DuoTaiDemo2 {public static void main(String[] args) {//Animal a = new Cat();//类型提升。 向上转型。//a.eat();//如果想要调用猫的特有方法时，如何操作？//强制将父类的引用。转成子类类型。向下转型。///Cat c = (Cat)a;//c.catchMouse();//千万不要出现这样的操作，就是将父类对象转成子类类型。//我们能转换的是父类应用指向了自己的子类对象时，该应用可以被提升，也可以被强制转换。//多态自始至终都是子类对象在做着变化。//Animal a = new Animal();//Cat c = (Cat)a;/*毕姥爷 x = new 毕老师();x.讲课();毕老师 y = (毕老师)x;y.看电影();*/function(new Dog());function(new Cat());}public static void function(Animal a)//Animal a = new Cat();{a.eat();/*if(a instanceof Animal){System.out.println("haha");}else */if(a instanceof Cat){Cat c = (Cat)a;c.catchMouse();}else if(a instanceof Dog){Dog c = (Dog)a;c.kanJia();}/*instanceof : 用于判断对象的类型。 对象 intanceof 类型(类类型 接口类型) */}}?class Fu{static int num = 5;void method1(){System.out.println("fu method_1");}void method2(){System.out.println("fu method_2");}static void method4(){System.out.println("fu method_4");}}class Zi extends Fu{static int num = 8;void method1(){System.out.println("zi method_1");}void method3(){System.out.println("zi method_3");}static void method4(){System.out.println("zi method_4");}}class DuoTaiDemo4{public static void main(String[] args) {//Fu f = new Zi();////System.out.println(f.num);////Zi z = new Zi();//System.out.println(z.num);//f.method1();//f.method2();//f.method3();Fu f = new Zi();System.out.println(f.num);f.method4();Zi z = new Zi();z.method4();/*在多态中成员函数的特点：在编译时期：参阅引用型变量所属的类中是否有调用的方法。如果有，编译通过，如果没有编译失败。在运行时期：参阅对象所属的类中是否有调用的方法。简单总结就是：成员函数在多态调用时，编译看左边，运行看右边。在多态中，成员变量的特点：无论编译和运行，都参考左边(引用型变量所属的类)。在多态中，静态成员函数的特点：无论编译和运行，都参考做左边。*///Zi z = new Zi();//z.method1();//z.method2();//z.method3();}}?abstract class 动物{abstract void eat();}class Dog extends 动物{public void eat(){//骨头;}}class 猫 extends 动物{public void eat(){//吃鱼；}}class 猪 extends 动物{public void eat(){//饲料；}}class Demo{public void method(动物 x)//new Dog(); new 猫();{x.eat();}/*public void method(猫 x){x.eat();}public void method(Dog x){x.eat();}public void method(猪 x){x.eat();}*/}class Main{public static void main(String[] args){Demo d = new Demo();d.method(new Dog());d.method(new 猫());}}动物 x = new 猫（）；//猫 x = new 猫（）；一。表现：父类或者接口的引用指向了或者接收了自己的子类对象。二。前提：1，类与类之间要有关系。继承，实现。2，通常都会有覆盖。三。好处：预先定义的程序可以运行后期程序的内容。增强了程序的扩展性。四。弊端：虽然可以预先使用，但是只能访问父类中已有的功能，运行的是后期子类的功能内容。不能预先使用子类中定义的特有功能。五。多态的注意事项：在代码中。对于成员函数：Fu f = new Zi(); f.method();编译时期：看左边。运行时期：看右边。因为成员函数有一个覆盖操作。毕姥爷和毕老师的故事。对于非私有的实例变量，静态变量，静态方法。编译和运行都看左边。老师要求记住结论。有空闲时间，就想想为什么？六。转型。子类对象被父类引用：子类对象在向上转型。将指向子类对象的父类应用转换成子类类型引用：向下转型。毕姥爷和毕老师的故事。class 毕姥爷{}class 毕老师 extends 毕姥爷{}毕姥爷 ly = new 毕老师();//毕老师向上转型为了毕姥爷。向上转型毕老师 ls = (毕老师)ly; //将代表毕老师对象的父类引用ly强制转换成了毕老师类型。向下转型。七。应用电脑使用。主板运行。class MainBoard{public void run(){//主板运行;}public void usePCI(PCI p)//PCI p = new NetCard();{if(p!=null){p.open();p.close();}}}//为了提高主板功能的扩展性。//定义了规则。让后期的出现的功能板块，只要覆盖该规则，就可以被这个主板使用。interface PCI{void open();void close();}class MainDemo{public static void main(String[] args){MainBoard mb = new MainBoard();mb.run();mb.usePCI(null);mb.usePCI(new NetCard());}}class NetCard implements PCI{public void open(){}public void close(){}}Object:是java中所有对象的直接或者间接的父类。它里面的方法都所有对象都具备的。常见方法：boolean equals(Object obj):用于比较两个对象是否相同。String toString(): 获取对象的字符串表现形式 类名@哈希值 getClass().getName()+"@"+Integer.toHexString(hashCode());Class getClass():获取正在运行的对象所属的字节码文件的对象。也就是说如果Demo d = new Demo();d.getClass():获取的就是d执行的对象所属的字节码文件Demo.class对象。通常在自定义对象时，因为对象中都有自己特有的描述，所以都会建立对象自身的特有比较方法，或者字符串表现形式。也就是说，会覆盖Object中的方法。/*Demo d1 = new Demo();Demo d2 = new Demo();d1.getClass() == d2.getClass();*/class Demo //extends Object{public String toString(){this.getClass().getName()+"#"+Integer.toHexString(this.hashCode());}}class Fu{void show(){System.out.println("fu show");}}class Zi extends Fu{void function(){super.show();//this.show();}void show(){System.out.println("zi show");}}/*class Computer{private MainBoard mb;Computer(){mb = new MainBoard();}public void play(){mb.run();}}*/???? ??/*Object:是所有对象的直接后者间接父类，传说中的上帝。该类中定义的肯定是所有对象都具备的功能。Object类中已经提供了对对象是否相同的比较方法。如果自定义类中也有比较相同的功能，没有必要重新定义。只要沿袭父类中的功能，建立自己特有比较内容即可。这就是覆盖。*/class Demo //extends Object{private int num;Demo(int num){this.num = num;}public boolean equals(Object obj)//Object obj = new Demo();{if(!(obj instanceof Demo))return false;Demo d = (Demo)obj;return this.num == d.num;}/*public boolean compare(Demo d){return this.num==d.num;}*/public String toString(){return "demo:"+num;}}class Person {}class ObjectDemo {public static void main(String[] args) {Demo d1 = new Demo(4);System.out.println(d1);//输出语句打印对象时，会自动调用对象的toString方法。打印对象的字符串表现形式。Demo d2 = new Demo(7);System.out.println(d2.toString());//Demo d2 = new Demo(5);//Class c = d1.getClass();////System.out.println(c.getName());//System.out.println(c.getName()+"@@"+Integer.toHexString(d1.hashCode()));//System.out.println(d1.toString());//Person p = new Person();///System.out.println(d1.equals(p));}}?class {public static void main(String[] args) {System.out.println("Hello World!");}}class Fu{private int num = 9;public void show1(){}public void setNum(int num){this.num = num;}Fu(){}}class Zi extends Fu{//int num = 4;void show(){int num = 7;System.out.println(super.num);}}Zi z = new zi();z.setNum(4);继承：特点：1，提高了代码的复用性。2，让类与类之间产生关系，是多态性的前提。Java中的继承。1，java只支持单继承，不支持多继承。为啥呢？答案：因为继承了多个父类如果有相同方法时，子类对象不确定运行哪一个。2，Java还支持多层继承。A-->B--->C 原来可以形成继承体系。想要使用体系功能，"查阅父类功能，建立子类对象调用功能。"注解：父类的由来其实是由事物中的共性内容不断向上抽取而来的。所以父类中定义的是该体系中的最基本，最共性功能。继承出现后，代码上也有一些特点：1，变量。当子父类中定义了相同的名称的成员变量，子类要使用父类中的同名变量时，需要使用关键字super来区分。一般不会出现这种情况，因为父类中有了，子类不需要定义。而且父类定义时，一般变量都私有化。2，函数。子类可以直接访问父类中非私有的成员函数。特殊情况：当子类中定义了与父类一模一样的方法时，会发生覆盖操作。大多指的是非静态方法。 最终会运行子类的方法，父类相当于被覆盖了。 函数的另一个特性：覆盖（重写，复写）。 什么时候用啊？ 当父类的功能要被修改时，不建议修改源码。因为是灾难。 只要通过一个类继承原有类，定义一个新的升级后的功能即可。 但是功能是相同的，只是实现方法改变。这是子类可以沿袭父类中的功能定义， 并重写功能内容。这就是覆盖。 覆盖很爽，但是有注意事项： 1，子类覆盖父类时，必须权限要大于等于父类权限。 2，静态不能覆盖非静态。3，构造函数。构造函数可以本类进行对象初始化，也可以给子类对象进行初始化。子类对象初始化过程：子类中的所有构造方法都会访问父类中空参数的构造函数，因为每一个构造函数的第一行，都有一句隐式的super语句。为什么要有这条语句？因为子类会获取到父类中的数据，必须要先明确父类对数据的初始化过程。当父类中没有空参数构造函数时，子类构造函数必须通过super句来明确要访问的父类中指定的构造函数。当时子类构造函数也可以通过this语句访问本类中的构造函数。但是子类中肯定，至少有一个构造函数会访问父类。抽象类：其实就是在分析事物时，事物中的功能有些是不明确的内容的。这些不明确内容就是抽象的。可以通过抽象函数来描述。抽象函数一定要定义在抽象类中，因为，抽象函数所在类，也必须被抽象标识。写法特点：1，抽象函数只对函数进行声明，没有函数主体。2，抽象类和抽象函数都需要用abstract修饰。3，抽象类不可以进行实例化。4，想要使用抽象功能，必须通过子类覆盖了父类中所有的抽象方法后，才可以对子类实例化。如果只覆盖了部分抽象方法，那么子类还是一个抽象类。也可以理解为：抽象类是一个父类，是不断向上抽取而来的，在抽取过程中，只抽取了方法声明，但没有抽取方法实现。抽象类和一半类差不多。区别：抽象类可以定义抽象方法。抽象类不可以建立对象。其实抽象类一样用于描述事物，既可以定义抽象方法，也可以定义非抽象方法。接口 初期理解：接口看上去是一个特殊的抽象类。里面存的都是抽象方法。 特点： 格式：1，通过interface来定义。2，接口中常见成员：常量，抽象方法。而且这些成员都有固定的修饰符。常量：public static final方法：public abstract 3，接口中的成员都是共有的。4，一个类可以对接口进行多实现，也弥补了多继承带来的安全隐患，所以java对多继承进行了改良。用多实现方法来体现多继承的特性。5，一个类可以继承一个类的同时，实现多个接口。6，接口与接口之间是继承关系，而且可以多继承。应用特点：1，接口是对外暴露的规则。2，接口是功能的扩展。3，接口的出现降低了耦合性。别忘了说的时候，需要举例。如usb。pci，主板。插座。抽象类和接口异同：相同：1，都可以在内部定义抽象方法。2，通常都在顶层。3，都不可以实例化，都需要子类来实现。不同点：1，抽象类中可以定义抽象方法和非抽象方法，而接口中只能定义抽象方法。2，接口的出现可以多实现。抽象类只能单继承。也就是说：接口的出现避免了单继承的局限性。3，继承和实现的关系不一致。继承：is a，实现：like a /*abstract class Fu{abstract int show();}class Zi extends Fu{int show1(){return 3;}}class Fu{void method(){System.out.println("method run");}}class Zi extends Fu{void method(){System.out.println("method zi run");}}class ArrayTool{public int getMax(int[] arr){}priavte int age;public void setAge()}运动员|--篮球运动员：|--足球运动员：*//*内部类的访问规则：1，内部类可以直接访问外部类中的成员，包括私有。之所以可以直接访问外部类中的成员，是因为内部类中持有了一个外部类的引用，格式 外部类名.this2，外部类要访问内部类，必须建立内部类对象。*/class Outer{private int x = 3;class Inner//内部类{//int x = 4;void function(){//int x = 6;System.out.println("innner :"+Outer.this.x);}}/**/void method(){Inner in = new Inner();in.function();}}class InnerClassDemo{public static void main(String[] args) {Outer out = new Outer();out.method();//直接访问内部类中的成员。//Outer.Inner in = new Outer().new Inner();//in.function();}}?/*内部类的访问规则：1，内部类可以直接访问外部类中的成员，包括私有。之所以可以直接访问外部类中的成员，是因为内部类中持有了一个外部类的引用，格式 外部类名.this2，外部类要访问内部类，必须建立内部类对象。访问格式：1,当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中。可以直接建立内部类对象。格式外部类名.内部类名 变量名 = 外部类对象.内部类对象;Outer.Inner in = new Outer().new Inner();2,当内部类在成员位置上，就可以被成员修饰符所修饰。比如，private：将内部类在外部类中进行封装。static:内部类就具备static的特性。当内部类被static修饰后，只能直接访问外部类中的static成员。出现了访问局限。在外部其他类中，如何直接访问static内部类的非静态成员呢？new Outer.Inner().function();在外部其他类中，如何直接访问static内部类的静态成员呢？uter.Inner.function();注意：当内部类中定义了静态成员，该内部类必须是static的。 当外部类中的静态方法访问内部类时，内部类也必须是static的。当描述事物时，事物的内部还有事物，该事物用内部类来描述。因为内部事务在使用外部事物的内容。class Body{private class XinZang{}public void show(){new XinZang().}}*/class Outer{private static int x = 3;static class Inner//静态内部类{static void function(){System.out.println("innner :"+x);}}static class Inner2{void show(){System.out.println("inner2 show");}}public static void method(){//Inner.function();new Inner2().show();}}class InnerClassDemo2{public static void main(String[] args) {Outer.method();//Outer.Inner.function();//new Outer.Inner().function();//直接访问内部类中的成员。//Outer.Inner in = new Outer().new Inner();//in.function();}}?/*内部类定义在局部时，1，不可以被成员修饰符修饰2，可以直接访问外部类中的成员，因为还持有外部类中的引用。但是不可以访问它所在的局部中的变量。只能访问被final修饰的局部变量。*/class Outer{int x = 3;void method(final int a){final int y = 4;class Inner{void function(){System.out.println(y);}}new Inner().function();}}class InnerClassDemo3{public static void main(String[] args) {Outer out = new Outer();out.method(7);out.method(8);}}??/*异常：就是程序在运行时出现不正常情况。异常由来：问题也是现实生活中一个具体的事物，也可以通过java的类的形式进行描述。并封装成对象。其实就是java对不正常情况进行描述后的对象体现。对于问题的划分：两种：一种是严重的问题，一种非严重的问题。对于严重的，java通过Error类进行描述。对于Error一般不编写针对性的代码对其进行处理。对与非严重的，java通过Exception类进行描述。对于Exception可以使用针对性的处理方式进行处理。无论Error或者Exception都具有一些共性内容。比如：不正常情况的信息，引发原因等。Throwable|--Error|--Exception2,异常的处理java 提供了特有的语句进行处理。try{需要被检测的代码；}catch(异常类 变量){处理异常的代码；(处理方式)}finally{一定会执行的语句；}3，对捕获到的异常对象进行常见方法操作。String getMessage()：获取异常信息。*/class Demo{int div(int a,int b)throws Exception//在功能上通过throws的关键字声明了该功能有可能会出现问题。{return a/b;}}class ExceptionDemo{public static void main(String[] args) {Demo d = new Demo();try{int x = d.div(4,1);System.out.println("x="+x);}catch (Exception e)//Exception e = new ArithmeticException();{System.out.println("除零啦");System.out.println(e.getMessage());// / by zero;System.out.println(e.toString());// 异常名称 ： 异常信息。e.printStackTrace();//异常名称，异常信息，异常出现的位置。//其实jvm默认的异常处理机制，就是在调用printStackTrace方法。//打印异常的堆栈的跟踪信息。}System.out.println("over");}}?/*异常：就是程序在运行时出现不正常情况。异常由来：问题也是现实生活中一个具体的事物，也可以通过java的类的形式进行描述。并封装成对象。其实就是java对不正常情况进行描述后的对象体现。对于问题的划分：两种：一种是严重的问题，一种非严重的问题。对于严重的，java通过Error类进行描述。对于Error一般不编写针对性的代码对其进行处理。对与非严重的，java通过Exception类进行描述。对于Exception可以使用针对性的处理方式进行处理。无论Error或者Exception都具有一些共性内容。比如：不正常情况的信息，引发原因等。Throwable|--Error|--Exception2,异常的处理java 提供了特有的语句进行处理。try{需要被检测的代码；}catch(异常类 变量){处理异常的代码；(处理方式)}finally{一定会执行的语句；}3，对捕获到的异常对象进行常见方法操作。String getMessage()：获取异常信息。在函数上声明异常。便于提高安全性，让调用出进行处理。不处理编译失败。*/class Demo{int div(int a,int b)throws Exception//在功能上通过throws的关键字声明了该功能有可能会出现问题。{return a/b;}}class ExceptionDemo1{public static void main(String[] args) //throws Exception{Demo d = new Demo();try{int x = d.div(4,0);System.out.println("x="+x);}catch (Exception e){System.out.println(e.toString());}System.out.println("over");}}?/*异常：就是程序在运行时出现不正常情况。异常由来：问题也是现实生活中一个具体的事物，也可以通过java的类的形式进行描述。并封装成对象。其实就是java对不正常情况进行描述后的对象体现。对于问题的划分：两种：一种是严重的问题，一种非严重的问题。对于严重的，java通过Error类进行描述。对于Error一般不编写针对性的代码对其进行处理。对与非严重的，java通过Exception类进行描述。对于Exception可以使用针对性的处理方式进行处理。无论Error或者Exception都具有一些共性内容。比如：不正常情况的信息，引发原因等。Throwable|--Error|--Exception2,异常的处理java 提供了特有的语句进行处理。try{需要被检测的代码；}catch(异常类 变量){处理异常的代码；(处理方式)}finally{一定会执行的语句；}3，对捕获到的异常对象进行常见方法操作。String getMessage()：获取异常信息。在函数上声明异常。便于提高安全性，让调用出进行处理。不处理编译失败。对多异常的处理。1，声明异常时，建议声明更为具体的异常。这样处理的可以更具体。2，对方声明几个异常，就对应有几个catch块。不要定义多余的catch块。如果多个catch块中的异常出现继承关系，父类异常catch块放在最下面。建立在进行catch处理时，catch中一定要定义具体处理方式。不要简单定义一句 e.printStackTrace(),也不要简单的就书写一条输出语句。*/class Demo{int div(int a,int b)throws ArithmeticException,ArrayIndexOutOfBoundsException//在功能上通过throws的关键字声明了该功能有可能会出现问题。{int[] arr = new int[a];System.out.println(arr[4]);return a/b;}}class ExceptionDemo2{public static void main(String[] args) //throws Exception{Demo d = new Demo();try{int x = d.div(5,0);System.out.println("x="+x);}catch(Exception e){System.out.println("hahah:"+e.toString());}catch (ArithmeticException e){System.out.println(e.toString());System.out.println("被零除了!!");}catch (ArrayIndexOutOfBoundsException e){System.out.println(e.toString());System.out.println("角标越界啦！！");}/**/System.out.println("over");}}?/*因为项目中会出现特有的问题，而这些问题并未被java所描述并封装对象。所以对于这些特有的问题可以按照java的对问题封装的思想。将特有的问题。进行自定义的异常封装。自定义异常。需求：在本程序中，对于除数是-1，也视为是错误的是无法进行运算的。那么就需要对这个问题进行自定义的描述。当在函数内部出现了throw抛出异常对象，那么就必须要给对应的处理动作。要么在内部try catch处理。要么在函数上声明让调用者处理。一般情况在，函数内出现异常，函数上需要声明。发现打印的结果中只有异常的名称，却没有异常的信息。因为自定义的异常并未定义信息。如何定义异常信息呢？因为父类中已经把异常信息的操作都完成了。所以子类只要在构造时，将异常信息传递给父类通过super语句。那么就可以直接通过getMessage方法获取自定义的异常信息。自定义异常：必须是自定义类继承Exception。继承Exception原因：异常体系有一个特点：因为异常类和异常对象都被抛出。他们都具备可抛性。这个可抛性是Throwable这个体系中独有特点。只有这个体系中的类和对象才可以被throws和throw操作。throws和throw的区别throws使用在函数上。throw使用在函数内。throws后面跟的异常类。可以跟多个。用逗号隔开。throw后跟的是异常对象。*/class FuShuException extends Exception //getMessage();{private int value;FuShuException(){super();}FuShuException(String msg,int value){super(msg);this.value = value;}public int getValue(){return value;}}class Demo{int div(int a,int b)throws FuShuException{if(b<0)throw new FuShuException("出现了除数是负数的情况------ / by fushu",b);//手动通过throw关键字抛出一个自定义异常对象。return a/b;}}class ExceptionDemo3{public static void main(String[] args) {Demo d = new Demo();try{int x = d.div(4,-9);System.out.println("x="+x);}catch (FuShuException e){System.out.println(e.toString());//System.out.println("除数出现负数了");System.out.println("错误的负数是："+e.getValue());}System.out.println("over");}}/*class Throwable{private String message;Throwable(String message){this.message = message;}public String getMessage(){return message;}}class Exception extends Throwable{Exception(String message){super(message);}}class Person{String name;Person(String name){this.name = name;}public String getName(){return name;}}class Student extends Person{Student (String name){super(name);}}new Sttdent("lisi").getName();*//*Exceptoin中有一个特殊的子类异常RuntimeException 运行时异常。如果在函数内容抛出该异常，函数上可以不用声明，编译一样通过。如果在函数上声明了该异常。调用者可以不用进行处理。编译一样通过；之所以不用在函数声明，是因为不需要让调用者处理。当该异常发生，希望程序停止。因为在运行时，出现了无法继续运算的情况，希望停止程序后，对代码进行修正。自定义异常时：如果该异常的发生，无法在继续进行运算，就让自定义异常继承RuntimeException。对于异常分两种：1，编译时被检测的异常。2，编译时不被检测的异常(运行时异常。RuntimeException以及其子类)*/class FuShuException extends RuntimeException{FuShuException(String msg){super(msg);}}class Demo{int div(int a,int b)throws Exception//throws ArithmeticException{if(b<0)throw new Exception("出现了除数为负数了");if(b==0)throw new ArithmeticException("被零除啦");return a/b;}}class ExceptionDemo4 {public static void main(String[] args) {Demo d = new Demo();int x = d.div(4,-9);System.out.println("x="+x);System.out.println("over");}}/*class Person{public void checkName(String name){//if(name.equals("lisi"))//NullPointerExceptionif("lisi".equals(name))//if(name!=null && name.equals("lisi"))System.out.println("YES");elseSystem.out.println("no");}}main(){Person p = new Person();p.checkName(null);}*//*finally代码块：定义一定执行的代码。通常用于关闭资源。*/class FuShuException extends Exception{FuShuException(String msg){super(msg);}}class Demo{int div(int a,int b)throws FuShuException{if(b<0)throw new FuShuException("除数为负数");return a/b;}}class ExceptionDemo5{public static void main(String[] args) {Demo d = new Demo();try{int x = d.div(4,-1);System.out.println("x="+x);}catch (FuShuException e){System.out.println(e.toString());return;//System.exit(0);//系统，退出。jvm结束。}finally{System.out.println("finally");//finally中存放的是一定会被执行的代码。}System.out.println("over");}}class NoException extends Exception{}public void method()throws NoException{连接数据库;数据操作;//throw new SQLException();关闭数据库;//该动作，无论数据操作是否成功，一定要关闭资源。try{连接数据库;数据操作;//throw new SQLException();}catch (SQLException e){会对数据库进行异常处理;throw new NoException();}finally{关闭数据库;}}第一个格式：try{}catch (){}第二个格式：try{}catch (){}finally{}第三个格式：try{}finally{}//记住一点：catch是用于处理异常。如果没有catch就代表异常没有被处理过，如果该异常是检测时异常。那么必须声明。class Demo{public void method(){try{throw new Exception();}finally{//关资源。}}}class {public static void main(String[] args) {System.out.println("Hello World!");}}?/*异常在子父类覆盖中的体现；1，子类在覆盖父类时，如果父类的方法抛出异常，那么子类的覆盖方法，只能抛出父类的异常或者该异常的子类。2，如果父类方法抛出多个异常，那么子类在覆盖该方法时，只能抛出父类异常的子集。3，如果父类或者接口的方法中没有异常抛出，那么子类在覆盖方法时，也不可以抛出异常。如果子类方法发生了异常。就必须要进行try处理。绝对不能抛。*/class AException extends Exception{}class BException extends AException{}class CException extends Exception{}/*Exception |--AException|--BException|--CException*/class Fu{void show()throws AException{}}class Test{void function(Fu f){try{f.show();}catch (AException e){}}}class Zi extends Fu{void show()throws CException{}}class {public static void main(String[] args) {Test t = new Test();t.function(new Zi());}}?异常：是什么？是对问题的描述。将问题进行对象的封装。------------异常体系：Throwable|--Error|--Exception|--RuntimeException异常体系的特点：异常体系中的所有类以及建立的对象都具备可抛性。也就是说可以被throw和throws关键字所操作。只有异常体系具备这个特点。--------------throw和throws的用法：throw定义在函数内，用于抛出异常对象。throws定义在函数上，用于抛出异常类，可以抛出多个用逗号隔开。当函数内容有throw抛出异常对象，并未进行try处理。必须要在函数上声明，都在编译失败。注意，RuntimeException除外。也就说，函数内如果抛出的RuntimeExcpetion异常，函数上可以不用声明。--------------如果函数声明了异常，调用者需要进行处理。处理方法可以throws可以try。异常有两种：编译时被检测异常该异常在编译时，如果没有处理(没有抛也没有try)，编译失败。该异常被标识，代表这可以被处理。运行时异常(编译时不检测)在编译时，不需要处理，编译器不检查。该异常的发生，建议不处理，让程序停止。需要对代码进行修正。--------------异常处理语句：try{需要被检测的代码；}catch (){处理异常的代码；}finally{一定会执行的代码；}有三个结合格式：1.try{}catch (){}2.try{}finally{}3.try{}catch (){}finally{}注意：1，finally中定义的通常是 关闭资源代码。因为资源必须释放。2，finally只有一种情况不会执行。当执行到System.exit(0);fianlly不会执行。--------------自定义异常：定义类继承Exception或者RuntimeException1,为了让该自定义类具备可抛性。2，让该类具备操作异常的共性方法。当要定义自定义异常的信息时，可以使用父类已经定义好的功能。异常异常信息传递给父类的构造函数。class MyException extends Exception{MyException(String message){super(message);}}自定义异常：按照java的面向对象思想，将程序中出现的特有问题进行封装。--------------异常的好处：1，将问题进行封装。2，将正常流程代码和问题处理代码相分离，方便于阅读。异常的处理原则：1，处理方式有两种：try 或者 throws。2，调用到抛出异常的功能时，抛出几个，就处理几个。一个try对应多个catch。3，多个catch，父类的catch放到最下面。4，catch内，需要定义针对性的处理方式。不要简单的定义printStackTrace，输出语句。也不要不写。当捕获到的异常，本功能处理不了时，可以继续在catch中抛出。try{throw new AException();}catch (AException e){throw e;}如果该异常处理不了，但并不属于该功能出现的异常。可以将异常转换后，在抛出和该功能相关的异常。或者异常可以处理，当需要将异常产生的和本功能相关的问题提供出去，当调用者知道。并处理。也可以将捕获异常处理后，转换新的异常。try{throw new AException();}catch (AException e){// 对AException处理。throw new BException();}比如，汇款的例子。异常的注意事项：在子父类覆盖时：1，子类抛出的异常必须是父类的异常的子类或者子集。2，如果父类或者接口没有异常抛出时，子类覆盖出现异常，只能try不能抛。参阅ExceptionTest.java 老师用电脑上课ExceptionTest1.java 图形面积。class {public static void main(String[] args) {int x = 0;try{x = 4;}catch (){}finally{System.out.println("x="+x);}}}?注：按Java规范书写程序代码，如果你认为程序有错误，请指出，并说明程序错误原因。1.写出程序结果class Demo{public static void func()//throws Exception{try{throw new Exception();}finally{System.out.println("B");}}public static void main(String[] args){try{func();System.out.println("A");}catch(Exception e){System.out.println("C");}System.out.println("D");}}编译失败：如果func放上声明了该异常。结果是？B C D====================================================================2.写出程序结果class Test{Test(){System.out.println("Test");}}class Demo extends Test{Demo(){//super();System.out.println("Demo");}public static void main(String[] args){new Demo();new Test();}}TestDemoTest考的子类的实例化过程。====================================================================3.写出程序结果interface A{} class B implements A{public String func(){return "func";}}class Demo{public static void main(String[] args){A a=new B();System.out.println(a.func());}}编译失败：因为A接口中并未定义func方法。====================================================================4.写出程序结果class Fu{boolean show(char a){System.out.println(a);return true;}}class Demo extends Fu{public static void main(String[] args){int i=0;Fu f=new Demo();Demo d=new Demo();for(f.show('A'); f.show('B')&&(i<2);f.show('C')){i++;d.show('D');}}boolean show(char a){System.out.println(a);return false;}}A B====================================================================5.写出程序结果interface A{}class B implements A{public String test(){return "yes";}}class Demo{static A get(){return new B();}public static void main(String[] args){A a=get();System.out.println(a.test());}}编译失败，因为A接口中没有定义test方法。====================================================================6.写出程序结果: class Super{int i=0;public Super(String a){System.out.println("A");i=1;}public Super(){System.out.println("B");i+=2;}}class Demo extends Super{public Demo(String a){//super();System.out.println("C");i=5;}public static void main(String[] args){int i=4;Super d=new Demo("A");System.out.println(d.i);}}B C 5====================================================================7.interface Inter{void show(int a,int b);void func();}class Demo{public static void main(String[] args){//补足代码；调用两个函数，要求用匿名内部类Inter in = new Inter(){public void show(int a,int b){}public void func(){}};in.show(4,5);in.func();}}====================================================================8.写出程序结果class TD{int y=6;class Inner{static int y=3; void show(){System.out.println(y);}}}class TC{public static void main(String[] args){TD.Inner ti=new TD().new Inner();ti.show();}}编译失败，非静态内部类中不可以定义静态成员。内部类中如果定义了静态成员，该内部类必须被静态修饰。====================================================================9.选择题，写出错误答案错误的原因，用单行注释的方式。class Demo{ int show(int a,int b){return 0;}}下面那些函数可以存在于Demo的子类中。A.public int show(int a,int b){return 0;}//可以，覆盖。B.private int show(int a,int b){return 0;}//不可以，权限不够。C.private int show(int a,long b){return 0;}//可以，和父类不是一个函数。没有覆盖，相当于重载。D.public short show(int a,int b){return 0;}//不可以，因为该函数不可以和给定函数出现在同一类中，或者子父类中。E.static int show(int a,int b){return 0;}//不可以，静态只能覆盖静态。====================================================================10.写出this关键字的含义，final有哪些特点？this：代表本类对象，哪个对象调用this所在函数，this就代表哪个对象。final:1,修饰类，变量(成员变量，静态变量，局部变量)，函数。2，修饰的类不可以被继承。3，修饰的函数不可以被覆盖。4，修饰的变量是一个常量，只能赋值一次。====================================================================11.写出程序结果： class Fu{int num=4;void show(){System.out.println("showFu");}}class Zi extends Fu{int num=5;void show(){System.out.println("showZi");}}class T{public static void main(String[] args){Fu f=new Zi();Zi z=new Zi();System.out.println(f.num); System.out.println(z.num); f.show(); z.show(); }}45showZishowZi====================================================================12.interface A{void show();}interface B{void add(int a,int b);}class C implements A,B{//程序代码private int a,b;//private int sum;public void add(int a,int b){this.a =a;this.b = b;//sum = a+b;}public void show(){System.out.println(a+b);//System.out.println(sum);}}class D{public static void main(String[] args){C c=new C();c.add(4,2);c.show();//通过该函数打印以上两个数的和。}}====================================================================13.写出程序结果class Demo{public static void main(String[] args){try{showExce(); System.out.println("A");}catch(Exception e){System.out.println("B");}finally{System.out.println("C");}System.out.println("D");}public static void showExce()throws Exception{throw new Exception();}}// B C D====================================================================14.写出程序结果class Super{int i=0;public Super(String s){i=1;}}class Demo extends Super{public Demo(String s){i=2;}public static void main(String[] args){Demo d=new Demo("yes");System.out.println(d.i);}}//编译失败，因为父类中缺少空参数的构造函数。//或者子类应该通过super语句指定要调用的父类中的构造函数。====================================================================15.写出程序结果class Super{public int get(){return 4;}}class Demo15 extends Super{public long get(){return 5;}public static void main(String[] args){Super s=new Demo15();System.out.println(s.get());}}编译失败，因为子类父类中的get方法没有覆盖。但是子类调用时候不能明确返回的值是什么类型。所以这样的函数不可以存在子父类中。====================================================================16.写出程序结果：class Demo{public static void func(){try{throw new Exception();System.out.println("A");}catch(Exception e){System.out.println("B");}}public static void main(String[] args){try{func();}catch(Exception e){System.out.println("C");}System.out.println("D");}}//编译失败。 因为打印“A”的输出语句执行不到。记住：throw单独存在，下面不要定义语句，因为执行不到。====================================================================17.class Demo{public void func(){//位置1；new Inner();}class Inner{}public static void main(String[] args){Demo d=new Demo();// 位置2 new Inner();//不可以，因为主函数是静态的。如果访问inner需要被static修饰。}}A.在位置1写 new Inner();//okB.在位置2写 new Inner();C.在位置2写 new d.Inner();//错误，格式错误。new new Demo().Inner();D.在位置2写 new Demo.Inner();//错误，因为inner不是静态的。====================================================================18.写出程序结果class Exc0 extends Exception{}class Exc1 extends Exc0{}class Demo{public static void main(String[] args){try{throw new Exc1();}catch(Exception e){System.out.println("Exception");}catch(Exc0 e){System.out.println("Exc0");}}}//编译失败。多个catch时，父类的catch要放在下面。====================================================================19.interface Test{void func();}class Demo{public static void main(String[] args){//补足代码；(匿名内部类)new Demo().show(new Test(){public void func(){}});}void show(Test t){t.func();}}====================================================================20.写出程序结果class Test{ public static String output=""; public static void foo(int i){ try{ if(i==1)throw new Exception(); output+="1"; } catch(Exception e){ output+="2"; return; } finally{ output+="3"; } output+="4"; }public static void main(String args[]){ foo(0);System.out.println(output);//134foo(1); System.out.println(output); //13423}} ====================================================================21.建立一个图形接口，声明一个面积函数。圆形和矩形都实现这个接口，并得出两个图形的面积。注：体现面向对象的特征，对数值进行判断。用异常处理。不合法的数值要出现“这个数值是非法的”提示，不再进行运算。====================================================================22.补足compare函数内的代码，不许添加其他函数。class Circle{private static double pi=3.14;private double radius;public Circle(double r){radius=r;}public static double compare(Circle[] cir){//程序代码//其实就是在求数组中的最大值。int max = 0;//double max = cir[0].radius;for(int x=1; x<cir.length; x++){if(cir[x].radius>cir[max].radius)max = x;}return cir[max].radius;}}class TC{public static void main(String[] args){Circle cir[]=new Circle[3];//创建了一个类类型数组。cir[0]=new Circle(1.0);cir[1]=new Circle(2.0);cir[2]=new Circle(4.0);System.out.println("最大的半径值是："+Circle.compare(cir));}}====================================================================23.写出程序结果public class Demo{ private static int j = 0; private static boolean methodB(int k){j += k; return true; }public static void methodA(int i){ boolean b; b = i < 10 | methodB (4); b = i < 10 || methodB (8); }public static void main (String args[] ){methodA (0); System.out.println(j); //4} }====================================================================24.假如我们在开发一个系统时需要对员工进行建模，员工包含 3 个属性：姓名、工号以及工资。经理也是员工，除了含有员工的属性外，另为还有一个奖金属性。请使用继承的思想设计出员工类和经理类。要求类中提供必要的方法进行属性访问。 ====================================================================25.在一个类中编写一个方法，这个方法搜索一个字符数组中是否存在某个字符，如果存在，则返回这个字符在字符数组中第一次出现的位置（序号从0开始计算），否则，返回-1。要搜索的字符数组和字符都以参数形式传递传递给该方法，如果传入的数组为null，应抛出IllegalArgumentException异常。在类的main方法中以各种可能出现的情况测试验证该方法编写得是否正确，例如，字符不存在，字符存在，传入的数组为null等。getIndex(null,'a');public int getIndex(char[] arr,char key){if(arr==null)throw new IllegalArgumentException("数组为null");for(int x=0; x<arr.length; x++){if(arr[x]==key)return x;}return -1;}====================================================================26.补足compare函数内的代码，不许添加其他函数。class Circle{private double radius;public Circle(double r){radius=r;}public Circle compare(Circle cir){//程序代码/*if(this.radius>cir.radius)return this;return cir;*/return (this.radius>cir.radius)?this: cir;}}class TC{public static void main(String[] args){Circle cir1=new Circle(1.0);Circle cir2=new Circle(2.0);Circle cir;cir=cir1.compare(cir2);if(cir1==cir)System.out.println("圆1的半径比较大");elseSystem.out.println("圆2的半径比较大");}}package pack;/*为了简化类名的书写，使用一个关键字，import.import 导入的是包中的类。建议，不要写通配符 * ，需要用到包中的哪个类，就导入哪个类。c:\myclassc:\myclass\packb\DemoA.classc:\myclass\packb\haha\DemoZ.classimport packb.*;import packb.haha.*;建立定包名不要重复，可以使用url来完成定义，url是唯一的。www.itcast.cnpackage cn.itcast.demopackage cn.itcast.test*/import packb.haha.hehe.heihei.*;import packa.*;import packb.*;class PackageDemo{public static void main(String[] args) {DemoC c = new DemoC();//packa.DemoA d = new packa.DemoA();//d.show();//packb.DemoB d = new packb.DemoB();//d.method();}}/*PackageDemo.java:8: 找不到符号符号： 类 DemoA位置： 类 pack.PackageDemo DemoA d = new DemoA(); ^PackageDemo.java:8: 找不到符号符号： 类 DemoA位置： 类 pack.PackageDemo DemoA d = new DemoA(); ^2 错误错误原因：类名写错。因为类名的全名是：包名.类名PackageDemo.java:8: 软件包 packa 不存在 packa.DemoA d = new packa.DemoA(); ^PackageDemo.java:8: 软件包 packa 不存在 packa.DemoA d = new packa.DemoA(); ^2 错误错误原因：packa包不在当前目录下需要设置classpath，告诉jvm去哪里找指定的packa包。PackageDemo.java:8: packa.DemoA 在 packa 中不是公共的；无法从外部软件包中对其进行访问 packa.DemoA d = new packa.DemoA(); ^PackageDemo.java:8: packa.DemoA 在 packa 中不是公共的；无法从外部软件包中对其进行访问 packa.DemoA d = new packa.DemoA(); ^2 错误错误原因：有了包，范围变大，一个包中的类要被访问，必须要有足够大的权限。所以被访问的类要被public修饰。PackageDemo.java:9: show() 在 packa.DemoA 中不是公共的；无法从外部软件包中对其进行访问 d.show(); ^1 错误错误原因：类公有后，被访问的成员也要公有才可以被访问。总结：包与包之间进行访问，被访问的包中的类以及类中的成员，需要public修饰。不同包中的子类还可以直接访问父类中被protected权限修饰的成员。包与包之间可以使用的权限只有两种，public protected。 public protected default private同一个类中 ok ok ok ok同一个包中 ok ok ok子类 ok ok 不同包中 okjava.lang : java的核心包 jdk1.2版本以后，该包中的类自动导入。java.awt: 用于制作图形界面。java.io:input output 用于操作设备上的数据。java.util : 这里定义是java的工具类。集合，日期。java.net:用于网络通讯的。java.applet: application let server let servlet java server page jsp class haha implements Servletclass hehe extends HttpServlet*/---------------------- android培训、java培训、期待与您交流！ ----------------------详细请查看：http://edu.csdn.net/heima