java成员变量与局部变量
JAVA基础之局部变量与全局变量以及成员变量的区别
JAVA基础之局部变量与全局变量以及成员变量的区别局部变量
定义:在⽅法内定义的变量称为“局部变量”或“临时变量”,⽅法结束后局部变量占⽤的内存将被释放。
全局变量
定义:全局变量,⼜称“外部变量”,它不是属于哪个⽅法,作⽤域从定义的地址开始到源⽂件结束。
注意事项:
当局部变量与全局变量重名时,起作⽤的是局部变量。
成员变量
定义:在类体的变量部分中定义的变量,也称为字段。
区别:
java中没有全局变量的定义,这是C中的
例:
class Demo{
int x;// ⾮静态成员变量,⼜称为属性,对该类不同的对象来说,属性是不同的
static int y;// 静态成员变量,⼀个类中只有⼀个该变量,该类不同的对象共享同⼀个静态成员变量
public static void main(String[] args){
int m = 0;// 局部变量,是⽅法内部定义的变量,只在⽅法内部可见,在该⽅法结束后,由垃圾回收器⾃动回收
}
}。
变量的有效范围
变量的有效范围变量的有效范围是指程序代码能够访问该变量的区域,若超出该区域访问变量,则编译时会出现错误。
有效范围决定了变量的生命周期,变量的生命周期是指从声明一个变量并分配内存空间开始,到释放该变量并清除所占用的内存空间结束。
进行变量声明的位置,决定了变量的有效范围,根据有效范围的不同,可以将变量分为以下两种。
成员变量:在类中声明,在整个类中有效。
局部变量:在方法内或方法内的某代码块(方法内部,“{”与“}”之间的代码)中声明的变量。
在代码块声明的变量,只在当前代码块中有效;在代码块外、方法内声明的变量在整个方法内都有效。
下面先来通过如下代码初步了解成员变量和局部变量的声明及使用范围。
public class Olympics {private int medal_All=800; //成员变量public void China(){int medal_CN=100; //方法的局部变量if(true){ //代码块int gold=50; //代码块的局部变量medal_CN+=50; //允许访问medal_All-=150; //允许访问}gold=100; //编译出错medal_CN+=100; //允许访问medal_All-=200; //允许访问}public void Other(){medal_All=800; //允许访问medal_CN=100; //编译出错, 不能访问其他方法中的局部变量gold=10; //编译出错}}1.成员变量类的成员变量又可分为两种:静态变量和实例变量。
静态变量是指通过static关键字进行修饰的成员变量,没有被static关键字修饰的变量为实例变量。
它们的区别如下。
静态变量的有效范围是整个类,并且可以被类的所有实例共享。
可以通过“类名.变量名”的方式来访问静态变量。
静态变量的生命周期取决于类的生命周期,当类被加载时,为类中的静态变量分配内存空间,当卸载类时,释放静态变量占用的空间,静态变量被销毁。
java面向对象总结(一)
java⾯向对象总结(⼀)1. 对象的概念及⾯向对象的三个基本特征⾯向对象的三⼤核⼼特性⾯向对象开发模式更有利于⼈们开拓思维,在具体的开发过程中便于程序的划分,⽅便程序员分⼯合作,提⾼开发效率。
⾯向对象程序设计有以下优点。
1. 可重⽤性:它是⾯向对象软件开发的核⼼思路,提⾼了开发效率。
⾯向对象程序设计的抽象、继承、封装和多态四⼤特点都围绕这个核⼼。
2. 可扩展性:它使⾯向对象设计脱离了基于模块的设计,便于软件的修改。
3. 可管理性:能够将功能与数据结合,⽅便管理。
该开发模式之所以使程序设计更加完善和强⼤,主要是因为⾯向对象具有继承、封装和多态 3 个核⼼特性。
继承性如同⽣活中的⼦⼥继承⽗母拥有的所有财产,程序中的继承性是指⼦类拥有⽗类数据结构的⽅法和机制,这是类之间的⼀种关系;继承只能是单继承。
例如定义⼀个语⽂⽼师类和数学⽼师类,如果不采⽤继承⽅式,那么两个类中需要定义的属性和⽅法.语⽂⽼师类和数学⽼师类中的许多属性和⽅法相同,这些相同的属性和⽅法可以提取出来放在⼀个⽗类中,这个⽗类⽤于被语⽂⽼师类和数学⽼师类继承。
当然⽗类还可以继承别的类,学校主要⼈员是⼀个⼤的类别,⽼师和学⽣是学校主要⼈员的两个⼦类,⽽⽼师⼜可以分为语⽂⽼师和数学⽼师两个⼦类,学⽣也可以分为班长和组长两个⼦类。
使⽤这种层次形的分类⽅式,是为了将多个类的通⽤属性和⽅法提取出来,放在它们的⽗类中,然后只需要在⼦类中各⾃定义⾃⼰独有的属性和⽅法,并以继承的形式在⽗类中获取它们的通⽤属性和⽅法即可。
封装性封装是将代码及其处理的数据绑定在⼀起的⼀种编程机制,该机制保证了程序和数据都不受外部⼲扰且不被误⽤。
封装的⽬的在于保护信息,使⽤它的主要优点如下。
保护类中的信息,它可以阻⽌在外部定义的代码随意访问内部代码和数据。
隐藏细节信息,⼀些不需要程序员修改和使⽤的信息,⽐如取款机中的键盘,⽤户只需要知道按哪个键实现什么操作就可以,⾄于它内部是如何运⾏的,⽤户不需要知道。
第一章-Java基础笔记
第⼀章-Java基础笔记Java语⾔的概述Java是⼀门⾯向对象的语⾔,Java相对于C语⾔来说学习相对简单,它主要的三⼤特点就是:封装、继承、多态,并且只需要进⾏⼀次源码编译,在任何装有对应版本的JVM 虚拟机环境的计算机下运⾏;Java的三个版本JavaSE主要⽤于桌⾯应⽤的开发JavaME主要⽤于嵌⼊式系统的开发JavaEE主要⽤于企业级的WEB端开发和服务器开发Java环境介绍JDK - 提供了开发者的⼀些⼯具包,并包含了[JRE和JVM]JRE - Java的运⾏环境,提供了运⾏时需要的类库,并包含了[JVM]JVM - Java的虚拟⼀块内存区域,⽤于执⾏Java的代码Java跨平台交互图Java代码的运⾏机制后缀点java的⽂件会通过 javac命令进⾏⽂件的编译成⼀个能够被JVM读懂的字节码⽂件,通过加载、校验、初始化的过程都内存中,通过JVM寄存器读取⽂件中的⾏号,进⾏执⾏相关代码;注释注释是为了在编写程序时对某个类、⽅法或是⼀段代码进⾏功能作⽤的说明,它不会被编译成代码执⾏,只是起到⼀个描述作⽤,便于对代码的理解;Java中的注释分为3种:单⾏注释://多⾏注释:/* */⽂档注释:/** */对注解的内容⽣成JavaDoc⽂档DOS命令进⼊到要⽣成Doc⽂档的层级⽬录,执⾏:javadoc -encoding UTF-8 -charset UTF-8 ⽂件名称/*** @Author JavaCat7* @Description 这是⼀个⽂档注释*/public class Demo{/*** @Parameter args 对参数的描述* @Description 这是⼀个⽂档注释*/public static void main(String[] args){//这是⼀个单⾏注释System.out.println("Hello Java");/*这是多⾏注释这是多⾏注释*/}}标识符每个⼈都有名字,⽽标识符是为了给代码中的类、接⼝、⽅法、变量取⼀个名字,但它们的明⽩是有着严格规范的;规范:每个⼈都有名字,⽽标识符是为了给代码中的类、接⼝、⽅法、变量取⼀个名字,但它们的明⽩是有着严格规范的;**规范:**1.严格区分⼤⼩写;2.开头可以是$ 或 _ 或 A-Z a-z的字母组成,也可以汉字(不会这么⼲);3.可以由数字、字母或者是 $ 或 _ 组成,但数字不能⽤于开始;4.不可以包含特殊字符;5.不能以Java语⾔中的保留字作为命名;6.类名采取⼤驼峰命名法;7.⽅法和变量采取⼩驼峰命名法;8.常量采取⼤学加_进⾏命名;基本数据类型Java是强类型计算机语⾔,所有的变量必须先定义才能使⽤,对于强类型⽽⾔主要就是指的数据安全,强类型的语⾔有很多,⽐如C、C++、python...计算机存储单位换算bit(位) - 是计算内部数据存储的最⼩单元,通过8个⼆进制位进⾏表⽰;byte(字节) - 是计算机中数据处理的基本单位,通常使⽤B来表⽰;8个bit(位) = 1B(字节)1024个B(字节) = 1KB1024个KB = 1MB1024个MB = 1GB....//整数类型byte a = 1;short b = 2;int c = 3;long d = 4L;//⼩数类型float e = 5.0f;duble f = 6.0d;//字符类型char g = 'a';//布尔类型boolean h = true;boolean i = false;数据类型的转换各数值相关数据类型⽀持类型上的转换,既可以把排序级别较低的类型转换成排序级别较⼤的类型,也可以把排序级别较⾼的类型转换成级别较低的类型(但会造成数据的丢失);数据的转换强制类型转换 - 在要转换的变量前使⽤:要转换的对应数据类型如- (int)⾃动类型转换 - 在不同的数值数据类型运算中,它会以排序级别较⾼的数据类型作为基础⾃动转换int number1 = 128;//正常byte的值是 -128 - 127,强制把int类型转换成byte会造成数据的不精确byte number2 = (byte)number1;int number3 = 519;float number4 = 1.0f;//在运算过程中因为float的排序级别⽐int⾼,那么它会⾃动转换成float类型在完成运算float number5 = number3 + number4;变量,静态变量,常量及作⽤域变量是指可以变化的值,通过数据类型和变量名可以在内存中申请⼀块存储的空间,通过内存的引⽤地址可以设置改变内存中存储的值或者修改值,所有的变量必须先赋值才可以使⽤;成员变量成员变量是指在类中与⽅法同级的位置中定义的成员变量,在该位置定义的变量可以不⽤设置值就可以使⽤,因为它会对类进⾏初始化,并完成初始化赋值,就算不给他们赋值也会有默认的初始值,他们的默认初始值都是最⼩的单元;作⽤域成员位置的变量,可以在⾮静态⽅法的所有位置使⽤,如果要在静态⽅法中使⽤,需要先创建对象;public class Variable{int a; //默认为:0float b; //默认为:0.0char c; //默认为:''boolean d; //默认为:false}局部变量局部变量是指在⽅法内部定义的变量,必须要先完成初始化后,才可以被使⽤;作⽤域局部位置的变量,外部⽆法使⽤,只能在⽅法内部使⽤,可以和外部的变量名称相同;public class Variable{int number;public void method(){int number = 3;//可以和成员位置的变量名称相同}}静态变量静态变量是指被static关键字修饰的变量,被修饰的变量⼜称为类变量;作⽤域静态变量可以作⽤域与所有⽅法中,静态变量只能定义在类的成员位置;public class Variable{static int number ;public static void main(String[] arags){System.out.println(number);}public void method(){System.out.println(numbe);}}常量常量是指不能被改变的值,它在创建到成员位置必须要先完成赋值,⼀旦被创建它的值是不允许被更改的;作⽤域它的作⽤域和成员变量相同public class Variable{final int NUMBER = 3.1415926;}静态常量静态常量是指从属于类的常量,在完成初始化以后是不可以被修改的,并且被public所进⾏修饰;作⽤域它的作⽤域和静态变量相同运算符算术运算符int a = 5;int b = 2;int number = a + b; //number = 7;int number = b - a; //number = 3;int number = a * b; //number = 10;int number = a / b; //number = 2,只取整数;double number = a / (double)b; //number = 2.5int number = a % b; //number = 1;⾃增⾃减运算符int a = 1;int b;b = a++; //b = 1; 先把a的值赋值给b,后a进⾏ +1 操作;b = a--; //b = 2; a前⾯进⾏了⾃增那么就是2,先把2赋值给b,然后进⾏ -1 操作;b = ++a; //b = 2; 前⾯a进⾏了⾃减那么就是1,先对a进⾏⾃增加1,然后在赋值给b;b = --a; //b = 1; 前⾯a是2,先对a进⾏⾃减1,在赋值给b;赋值运算符int a = 5;//把 5 赋值给 a;int b = 2;//把 2 赋值给 b;a += b; // a = 7(a+b的结果在赋值给a);a -= b; // a = 3;a *= b; // a = 10;a /= b; // a = 2;a %= b; // a = 1;关系运算符int a = 5;int b = 2;a > b; //truea < b; //falsea >= b; //falsea <= b; //truea == b; //falsea != b; //true逻辑运算符boolean a = true;boolean b = false;a &&b = false;//都true则true,第⼀个条件为false就不会在看第⼆个条件,直接返回falsea ||b = true;//⼀个条件为true则true,第⼀个条件为tre就不看第⼆个条件,直接返回true! a = false;//取反a &b = false;//2个条件都要执⾏a |b = true;三元运算符int a = 5;int b = 5;a ==b ? "等于":"不等于"; //为true返回第⼀个,为false返回第⼆个流程控制语句If语句if语句就是判断条件是否成⽴,成⽴就执⾏if中的代码,不成⽴就不进⼊;boolean flag = true;if(flag){System.out.println("...");}if...else语句if...else语句就是根据判断的条件是否成⽴,成⽴⾛if语句,不成⽴⾛else语句;boolean flag = true;if(flag){System.out.println("成⽴");}else{System.out.println("不成⽴");}if...else if语句if...else if⽀持多条件的判断,只会进⼊⼀个匹配的条件;boolean flag = true;boolean fail = false;if(flag){System.out.println("条件匹配");}else if(fail){System.out.println("条件匹配");}else{System.out.println("条件都不匹配");}switch条件控制语句witch语句从JDK1.7开始可以⽀持匹配:String字符串;注意事项:每个case 后⾯必须跟⼀个数值常量或字符串常量⽤于匹配;匹配的语句后⾯需要加上break关键字,防⽌case穿透;String week = "星期⼀";switch(week){case "星期⼀":System.out.println("今天是星期⼀");break;case "星期⼆":System.out.println("今天是星期⼆");break;case "星期三":System.out.println("今天是星期⼆");break;default:System.out.println("今天星期⼏都不是");}循环控制语句for循环语句for(初始值,条件表达式,更新)for(int i = 1 ; i <= 10 ; i++){System.out.println(i);}增强for循环for(接收类型的变量,表达式)int [] arrays = {1,2,3,4,5,6,7,8,9,10};for(int i : arrays){System.out.println(arrays);}while循环语句while(条件表达式)int number = 1;while(number <= 100){System.out.println(number);number ++;}do...while循环语句do{先把语句执⾏⼀遍}while(条件表达式);boolean flag = true;do{System.out.println("先执⾏⼀遍");flag = false;}while(flag);break和continue关键字break关键字结束循环的意思;for(int i = 1; i <= 100; i++){if(i == 10){System.out.println("打印10后结束循环");break;}}continue关键字跳过当前循环,进⼊下⼀次循环;for(int i = 1 ; i <= 10; i ++){if(i % 2 == 1){continue;}System.out.println("打印:"+i);}⽅法概述:⽅法就相当于使⽤多⾏代码进⾏组合去实现的⼀个功能⽚段,对代码进⾏封装利⽤,可实现多次调⽤;⽅法的定义修饰符返回值⽅法名称(形参形参名称){⽅法体}public class Function{public static void main(String[] arags){}public void method1(){}public void method2(String name,int age){}public static void method3(){}public int method03(){int a = 3;return a;}public int method04(int a,int b){if(a == b){System.out.println(a + "和" + b + "相等");return -1;}return a > b ? a : b;}}⽅法的重载⽅法的重载是指⽅法名称相同,传递的参数类型不同,个数不同,顺序不同与返回值⽆关;这样的⽅法被称为⽅法的重载;public class Function{public int max(int a,int b) {return a > b ? a : b;}public double max(double a,double b){return a > b ? a : b;}}形参和实参形参是指在()内部的参数,实参是指被真实传递的参数;public class Function{public static vid main(String[] args){Function function = new Function();function.max(3,5);}public int max(int a,int b) {return a > b ? a : b;}}可变参数在⽅法的()中我们有时候不知道要传递多少参数,那么我们可以传递⼀个数据类型紧跟后⾯加上...来表⽰;但需要注意的是⼀个⽅法中指允许⼀个可变参,如果有其他类型的参数,那么可变参数需要写在最后⾯;可变参数本质上就是⼀个数组;public class Function{public void method(String name,int... numbers){for(int num : numbers){System.out.println(num);}}}递归递归的本质就是⾃⼰调⽤⾃⼰,它可以解决⼀些业务,但效率和开销较⼤,对⼀些⽐较⼩的运算可以使⽤;//递归求3的阶乘public class Founction{public static void main(String[] args){}public int founction(int number){int result = 1;if(number == result){return result;}return number * founction(number - 1);}}数组数组就是⼀组数据的集合,Java中的数组必须存储和数据类型相符合的值,不允许与定义的数据类型不匹配;⼀旦数组被创建出来,它的长度就不允许被改变,数组有下标(索引)的概念,都是从0开始,如果操作的数据超过数组的长度那么就会报出下标索引越界异常[ IndexOutofBoundsException ];数组的定义int[] array = new int[3];int array[] = new int[3];int array[] = {1,2,3};数组的内存模型图数组的遍历⽅式int[] arr = new int[10];//⽅式⼀for (int i = 0; i < arr.length ; i ++) {System.out.println(arr[i]);}//⽅式⼆for (int num : arr) {System.out.println(num);}⼆维数组int[][] arr = new int[3][2];String[][] strArr = {{"hello","hello"},{"hi","hi","hi",{"java","java","java","java"}}Arrays⼯具类Arrays数组的⼯具类,是jdk已经帮我们提供好的⼀套数据⼯具类,⽅便我们对数据相关进⾏⼀些操作;int[] arr = {3,51,1,33,82,22,55,53};Arrays.toString(arr);//把数组变成⼀个字符串Arrays.sort(arr);//对数组内容进⾏升序排列Arrays.fill(arr,0);//把数组的内容全部进⾏替换为0常见算法冒泡排序public static int[] arr = new int[]{5, 2, 7, 4, 6, 9, 8, 13, 19, 11, 17, 15};//冒泡排序算法public static void popArithmetic(int[] arr) {//⽐较的轮数是数组长度-1for (int i = 0; i < arr.length - 1; i++) {//每次⽐较⼀轮,需要减少1次⽐较的次数for (int j = 0; j < arr.length - i - 1; j++) {//如果前⾯的数据⽐后⾯⼤,那么就交换位置if (arr[j] > arr[j + 1]) {int temp = arr[j];arr[j] = arr[j + 1];arr[j + 1] = temp;}}}System.out.println("最终结果是:" + Arrays.toString(arr));}选择排序public static int[] arr = new int[]{5, 2, 7, 4, 6, 9, 8, 13, 19, 11, 17, 15};//选择排序public static void selectOrderArithmetic(int[] arr) {//⽐较的轮数是数组长度-1for (int i = 0; i < arr.length - 1; i++) {//每⽐较⼀次,需要减少1次⽐较的次数,会把⼩的先往前排for(int j = i+1;j<arr.length;j++){if(arr[i]>arr[j]){int temp = arr[i];arr[i] = arr[j];arr[j] = temp;}}}System.out.println("最终结果是:" + Arrays.toString(arr));}⼆分查找public static int[] arr = new int[]{1, 2, 3 , 4, 6, 7, 8, 13, 19};//2分查找法public static void branchFind(int [] arr,int number){int startNode = 0;int endNode = arr.length-1;int middle = 0;while (startNode <= endNode){//中间的指针由开始节点和结束节点计算得来middle = (startNode+endNode)/2;if(number == arr[middle]){System.out.println("找到了");break;}else if(number < arr[middle]){endNode=middle-1;System.out.println(number+"⼩于中间值,结束节点变更为中间节点-1"); }else if(number > arr[middle]){startNode = middle+1;System.out.println(number+"⼤于中间值,开始节点变更为中间节点+1"); }else{System.out.println("没有找到该元素");break;}}}。
JAVA篇:修饰符与接口、类、方法、成员变量、局部变量、方法块
JAVA篇:修饰符与接⼝、类、⽅法、成员变量、局部变量、⽅法块或许这是⼀个⽐较轻松简单的知识点,因为只是简单地做⼀个总览对⽐⽽已。
这周⽐较忙,祝我⾃⼰好运。
有关接⼝(interface)的修饰符,其实⼀般⽤public,也可以不加修饰词(default),或者是使⽤private修饰的声明在类的内部的内部接⼝。
不存在protected修饰的接⼝。
⽽接⼝内部可以有⽤public static final修饰的静态常量,除此之外只存在public修饰的⽅法(接⼝中⽆修饰词的⽅法也默认是public)了。
⽆论是接⼝还是接⼝中的⽅法的abstract修饰词都是隐含的,不必显式地修饰在接⼝或者⽅法前⾯。
类的访问限制修饰词与接⼝⼀样,但是还可以有⾮访问限制修饰词abstract(抽象类)和final(不可继承的类)。
类的成员变量可以被四种访问修饰词修饰,同时也可以被static(静态变量),final(常量),transtient(有关序列化特殊标识变量,具体还需要进⾏了解), volatie(线程共享变量)。
类⽅法除了访问限制修饰符,还可使⽤static(静态⽅法),final(不可改变的⽅法),abstract(抽象的),native(⾮java实现的),synchronized(线程同步),类构造⽅法只可使⽤访问限制修饰符修饰,局部变量只能使⽤final定义常量,⽅法块可以使⽤static定义静态⽅法块和使⽤synchronized 定义线程同步的⽅法块。
java的接⼝、类1、接⼝(interface) 在java中,接⼝是⼀个抽象类型,是抽象⽅法的集合,接⼝通常以interface来声明,接⼝只能包含抽象⽅法和以static\final修饰的变量,⼀个接⼝可以继承(extends)另⼀个接⼝。
接⼝只包含要实现的⽅法,⽽类描述对象的属性和⽅法,两者实现类似但是概念不同。
java提供了类和接⼝之间的实现机制,接⼝不可被实例化,只能被实现(implements),实现接⼝的类必须实现接⼝中全部的抽象⽅法,否则该类必须使⽤abstract声明为抽象类。
Java基础知识总结(超详细整理)
Java基础知识总结(超详细整理)Java语⾔的特点1.⾯向对象⾯向对象(OOP)就是Java语⾔的基础,也是Java语⾔的重要特性。
⾯向对象的概念:⽣活中的⼀切事物都可以被称之为对象,⽣活中随处可见的事物就是⼀个对象,我们可以将这些事物的状态特征(属性)以及⾏为特征(⽅法)提取并出来,并以固定的形式表⽰。
2.简单好⽤Java语⾔是由C和C++演变⽽来的,它省略了C语⾔中所有的难以理解、容易混淆的特性(⽐如指针),变得更加严谨、简洁、易使⽤。
3.健壮性Java的安全检查机制,将许多程序中的错误扼杀在摇蓝之中。
另外,在Java语⾔中还具备了许多保证程序稳定、健壮的特性(强类型机制、异常处理、垃圾的⾃动收集等),有效地减少了错误,使得Java应⽤程序更加健壮。
4.安全性Java通常被⽤在⽹络环境中,为此,Java提供了⼀个安全机制以防恶意代码的攻击,从⽽可以提⾼系统的安全性。
5.平台⽆关性Java平台⽆关性由Java 虚拟机实现,Java软件可以不受计算机硬件和操作系统的约束⽽在任意计算机环境下正常运⾏。
6.⽀持多线程在C++ 语⾔没有内置的多线程机制,因此必须调⽤操作系统的多线程功能来进⾏多线程程序设计,⽽ Java 语⾔却提供了多线程⽀持。
多线程机制使应⽤程序在同⼀时间并⾏执⾏多项任务,该机制使得程序能够具有更好的交互性、实时性。
7.分布式(⽀持⽹络编程)Java语⾔具有强⼤的、易于使⽤的⽹络能⼒,⾮常适合开发分布式计算的程序。
java中提供了⽹络应⽤编程接⼝(),使得我们可以通过URL、Socket等远程访问对象。
8.编译与解释共存Java语法基础标识符: ⽤来标识类名、对象名、变量名、⽅法名、类型名、数组名、⽂件名的有效字符序列。
合法的标识符:由字母、数字、下划线“_”、美元符号“$”或者“¥”组成,并且⾸字符不能是数字。
不能把java关键字和保留字作为标识符。
标识符对⼤⼩写敏感。
关键字:Java语⾔中已经赋予了特定含义的保留字: const、goto,Java版本中尚未使⽤,但以后版本可能会作为关键字使⽤变量:程序运⾏期间可以被改变的量。
JAVA程序设计复习题
题型:一、选择题(15*2 = 30分)二、填空题(10*1 = 10分)三、程序分析题(3*5 = 15分)四、编程题(3*15 = 45分)Java复习要点(1-5章)1.开发与运行Java程序需要经过哪些步骤和过程?编写源程序–》编译生成字节码文件–》运行2.Java程序由什么组成的?一个程序中必须要有public类吗?Java源文件的命名规则是怎样的?package声明import 导入外部包中的类class 类的声明注释一个Java文件中不一定要有public类,但是最多只能有一个public类。
如果源文件中有public 类,那么这个文件的名字必须和该类名完全相同。
3.Java源文件的扩展名是什么?编译后产生的字节码文件扩展名是什么?.java.class4.Java语言的注释都有哪些?// 单行注释/* 多行注释*//** 文档注释*/5.什么叫做标识符?Java语言规定的合法的标识符是怎样的?标识符:用来标识类名、变量名、方法名、类型名、数组名、文件名的有效字符序列。
Java语言规定标识符由字母、下划线、美元符号和数字组成,并且第一个字符不能是数字;并且不能使用Java关键字做标识符。
6.Java使用的unicode字符集有多少个字符?每个字符占用多少字节?655362个字节7.Java语言有哪些基本数据类型?这些基本数据类型各占多大内存空间?整型。
字符型。
浮点型。
布尔型。
8 16 32 648.掌握各种Java算术运算符和表达式的用法。
+ - * / % ++ --9.如何声明创建数组?声明数组:声明一维数组格式:数组元素类型数组名字[ ];数组元素类型[ ] 数组名字;例:float boy[ ]; double girl[ ] ; char cat[ ];声明二维数组格式:数组元素类型数组名字[ ][ ];数组元素类型[ ] [ ] 数组名字;例:float a[ ][ ]; double b[ ][ ]; char d[ ][ ];创建数组格式:数组名字=new 数组元素的类型[数组元素的个数];boy = new float[4];a = new float[5][3];10.如何获取数组的长度?数组名.length11.掌握if-else语句的使用。
java基础复习笔记之四(面向对象下)
说完了封装,接下来说说java的另两大特性:继承和多态。
之所以继承和多态放在一起,是本人觉得继承和多态联系较紧密。
总结为一句:有继承才会有多态。
一、继承:当我们了解了封装的概念后,知道可以把同一类事物的属性和功能封装到一个统一的描述中去,生成一个类。
然而后来我们发现,有时候这样做会做很多重复的动作。
比如我们抽象出一个猫类描述猫,然后抽象一个狗类描述狗。
但是我们发现猫类和狗类有许多相同的特性,比如说长毛,四腿走路等等。
为了避免这种重复工作,java提供了继承的机制。
那么我们怎么应用呢?示例如下:class 类A extends 类B{//code}表示类A继承类B,这个时候,类A就具有了类B中的除了private修饰以外的东西。
代码示例:class animal{//各种公有属性,比如,长毛,四腿走路...}class cat extends animal{}class dog extends animal{}继承的好处:A:提高了代码的复用性。
B:让类与类之间产生了关系,是多态的前提。
说了很多的东西,接下来总结下继承的概念。
1:继承:是以现有类型定义为基础来创建新类型的技术。
同类之间的继承,派生类可以享受基类所提供的服务的同时,还可以对基类的功能进行扩充,而不对基类本身进行修改。
这种重用技术大大提高了软件开发的效率。
(1)继承:在java中,我们在定义一个类的时候,可以不用全部定义类中的内容,通过继承把其他类的非私有功能可以直接拥有。
(2)父类:被继承的类。
(超类,基类)(了解)子类:继承其他类的类。
(派生类)(3)继承的好处:(掌握)A:提高代码的复用性。
B:让类与类之间产生了关系,是多态的前提。
(4)使用继承:(掌握)格式:class 类A extends 类B{}什么使用时候继承呢?假设判断法。
继承是:"is a"的关系"x is a y"(5)特点:(掌握)A:java只支持单继承(这句话的就是说,java一个类只能继承一个父类,换句话说,一个儿子只有一个亲爹,面向对象来源生活的体现。
java基础-类的定义、成员变量、方法、对象的创建与使用
java基础-类的定义、成员变量、⽅法、对象的创建与使⽤⼀.JAVA类的定义 JAVA⾥⾯有class关键字定义⼀个类,后⾯加上⾃定义的类名即可。
如这⾥定义的person类,使⽤class person定义了⼀个person类,然后在person这个类的类体⾥⾯定义person这个类应该具有的成员变量(即属性)和⽅法,如这⾥定义的int id和int age这个两个成员变量,或者叫属性,这个id表⽰⼈的⾝份证号码,⼈应该具有这个属性,age表⽰⼈的年龄,这也是⼈应该具有的。
这样就在person这个类⾥⾯定义了两个⼈应该有的属性,接下来就是定义⽅法了,这⾥定义了三个⽅法,分别是getAge()、setAge(int i)和getId(),分别⽤来获取⼈的年龄,设置⼈的年龄,获取⼈的id,getAge()⽅法获取了⼈的年龄后,将获取到的值返回,所以使⽤了return age语句,getId()⽅法也使⽤了return id语句⽤于返回获取到的id的值。
⼆. 成员变量 在JAVA⾥⾯的任何变量⾸先应该要声明,然后再赋值,然后再使⽤。
成员变量和局部变量有⼀个重要区别:成员变量在类⾥⾯声明时如果不进⾏初始化,那么JAVA会默认给它初始化,⽽局部变量JAVA不会默认给它初始化,所以在⽅法⾥⾯声明⼀个局部变量如果不给它初始化时就会出错。
默认初始化⼤多数都是0,boolean类型的为false,引⽤类型的为null,如过不记得JAVA对成员变量默认的初始化是多少的话,那就这样做,定义⼀个成员变量,不给它初始化,然后直接打印这个成员变量,打印出来的结果就是JAVA默认的初始化的值。
三、Java⾯向对象的基本概念——引⽤ 引⽤类型和基本类型有着巨⼤的区别,当声明⼀个int i=0时,系统会马上给这个i分配⼀个内存空间(在栈内存⾥⾯分配⼀⼩块区域⽤来装数字0),⾥⾯装着⼀个值为0,以后使⽤i这个名字马上就可以访问这个内存空间⾥⾯的值,这就是基本数据类型,所以基础类型就只占⼀块内存。
java基础知识大全(必看经典)
第一讲 Java语言入门1.1 Java的特点面向对象:•与C++相比,JAVA是纯的面向对象的语言C++为了向下兼容C,保存了很多C里面的特性,而C,众所周知是面向过程的语言,这就使C++成为一个"混血儿"。
而JAVA语法中取消了C++里为兼容C所保存的特性,如取消了头文件、指针算法、结构、单元等。
可移植〔平台无关性〕:•生成中间字节码指令与其他编程语言不同,Java并不生成可执行文件〔.exe文件〕,而是生成一种中间字节码文件〔.class文件〕。
任何操作系统,只要装有Java虚拟机〔JVM〕,就可以解释并执行这个中间字节码文件。
这正是Java实现可移植的机制。
•原始数据类型存储方法固定,避开移植时的问题Java的原始数据类型的大小是固定的。
比方,在任何机器上,整型都是32位,而C++里整型是依赖于目标机器的,对16位处理器〔比方8086〕,整数用两个字节表示;在像Sun SPARC这样的32位处理器中,整数用4个字节表示。
在Intel Pentium处理器上,整数类型由具体的操作系统决定:对于DOS和Win32来说,整数是2个字节;对于Windows 9x 、NT和2000,整数是4个字节。
当然,使整数类型平台无关之后,性能必然有所下降,但就Java来说,这个代价是值得的。
Java的字符串,那么采用标准的Unicode格式保存。
可以说,没有这个特性,Java的可移植性也不可能实现。
简单•JAVA在语法上与C++类似JAVA的语法与C++很接近,有过C或者C++编程经验的程序员很容易就可以学会JAVA语法;•取消了C++的一些复杂而低效的特性比方:用接口技术代替了C++的多重继承。
C++中,一个类允许有多个超类,这个特性叫做"多重继承",多重继承使得编译器非常复杂且效率不高;JAVA 的类只允许有一个超类,而用接口〔Interface〕技术实现与C++的多继承相类似的功能其它被取消的特性包括:虚拟根底类、运算符过载等•JAVA的根本解释器和类支持模块大概仅40K即使参加根本的标准库和支持线程的模块,也才220K左右。
Java成员变量与局部变量的区别:
Java成员变量与局部变量的区别:
1. 从语法形式上看:成员变量是属于类的,⽽局部变量是在⽅法中定义的变量或是⽅法的参数;成员变量可以被 public,private,static 等修饰符所修
饰,⽽局部变量不能被访问控制修饰符及 static 所修饰;但是,成员变量和局部变量都能被 final 所修饰。
2. 从变量在内存中的存储⽅式来看:如果成员变量是使⽤static修饰的,那么这个成员变量是属于类的,如果没有使⽤static修饰,这个成员变量是
属于实例的。
⽽对象存在于堆内存,局部变量则存在于栈内存。
3. 从变量在内存中的⽣存时间上看:成员变量是对象的⼀部分,它随着对象的创建⽽存在,⽽局部变量随着⽅法的调⽤⽽⾃动消失。
4. 成员变量如果没有被赋初值:则会⾃动以类型的默认值⽽赋值(⼀种情况例外:被 final 修饰的成员变量也必须显式地赋值),⽽局部变量则不会
⾃动赋值。
浅谈Java中的变量
变量是指 数值可以改变的数据 。 与数学 中的变量不 同, 在计 算 变量在其所属对象创建之际就被系统默认初始化 , 如果需要 的话还 机程序设计语言 中的引入变量实质是对一个或几个存储 单元 的抽 可 以显示的初始化或通过构造函数对成员变量进行初始化。 局部变
象, 这样对存储 单元的操作可以转化为对 变量 的操作 。 变量在程 序 量则 没有默认 初始 化机制 , 必须在 定义之 初 即进行初始化 。 ia 用f l n
13值 .
下移动堆 栈指针 。 一 约束 限制 了程序 的 灵活性 , 以虽然 某些 这 所 J AVA数据存储在栈 中——特 别是对 象引用 ,I A f 是J VA对象不存 _ = {
基本类型数据的值直接存储于变量名所 代表的存储空间中。 引 储 其 中 。 用数据类型变量所代表的存储空间的值是指针 , 它指 向实例化后的 () h a )堆是 Jv 虚拟机所管理 的 内存 中最人 的 ・ 3堆( e p ; aa 块 对 象 , 过 n w运 算 实 现 。 通 e 域, 所有 线程所共享 , 被 在虚拟机启动时创建 。 创建 队的 要 H的足 对于对成 员变 量来讲 , 类变量属于该类对应的所有 实例 , 它们 存放 对象 实例 。 堆不 同于 堆栈 的好处是 : 解释器不需要知道璎 从堆 共享它 ; 而实例 变量则属 于对 应实例 。 类变量使用 时机 可通过“ 类 里分配多少 存储区域 , 也不必知 道存储的数 据在堆 晕存 活多长 时 名. 变量名” 问, 访 也可通过 “ 对象名 . 变量名” 但对于 实例变量只能 间。 。 因此 , 在堆里分配存储有很大的灵活性 。 当你需要创建 ‘ 个对 象 通过“ 象名 . 量名” 对 变 来访 问。a a Jv 语言中进 行赋值 操作或 函数调 的时候 , 只需要n w写一行简单的代码, e 当执行这行代码时 , 自动 会 用 中 传 递参 数 时遵 循值 传 递 原则 , 对基 本类 型 而 言传 递 的值 就 是 真 在堆里进行存储分配 。 堆是垃圾收集器管理 的主要 区域 。 正的信息本身 , 引用类型 的参数来说传递的是地址 ( 对 句柄 )而非 , () 4方法区 ( t o ra ,a a meh d ae )Jv 方法 区与Jv 堆一样是 各个 线 aa 对象 的全 部信息 。 Jv 变量 不但要先声 明, aa 还必须被初始化后才可 以使用。 成员
java中的类修饰符
java中的类修饰符、成员变量修饰符、方法修饰符。
类修饰符:public(访问控制符),将一个类声明为公共类,他可以被任何对象访问,一个程序的主类必须是公共类。
abstract,将一个类声明为抽象类,没有实现的方法,需要子类提供方法实现。
final,将一个类生命为最终(即非继承类),表示他不能被其他类继承。
friendly,默认的修饰符,只有在相同包中的对象才能使用这样的类。
成员变量修饰符:public(公共访问控制符),指定该变量为公共的,他可以被任何对象的方法访问。
private(私有访问控制符)指定该变量只允许自己的类的方法访问,其他任何类(包括子类)中的方法均不能访问。
protected (保护访问控制符)指定该变量可以别被自己的类和子类访问。
在子类中可以覆盖此变量。
friendly ,在统一报中的类可以访问,其他包中的类不能访问。
final,最终修饰符,指定此变量的值不能变。
static(静态修饰符)指定变量被所有对象共享,即所有实例都可以使用该变量。
transient(过度修饰符)指定该变量是系统保留,暂无特别作用的临时性变量。
volatile(易失修饰符)指定该变量可以同时被几个线程控制和修改。
方法修饰符:public(公共控制符)private(私有控制符)指定此方法只能有自己类等方法访问,其他的类不能访问(包括子类)protected(保护访问控制符)指定该方法可以被它的类和子类进行访问。
final,指定该方法不能被重载。
static,指定不需要实例化就可以激活的一个方法。
synchronize,同步修饰符,在多个线程中,该修饰符用于在运行前,对他所属的方法加锁,以防止其他线程的访问,运行结束后解锁。
native,本地修饰符。
指定此方法的方法体是用其他语言在程序外部编写的。
java类修饰符我们对java变量和方法的修饰符都比较了解,但却很少注意到类的修饰符,今天这个问题突然被问到,现在整理一下:java的修饰符有:权限修饰符:public、protected、default、private修饰符:abstract、static、finalpublic 使用对象:最广,类、接口、变量、方法protected使用对象:变量、方法注意:不能修饰类(外部类)default 使用对象:类、接口、变量、方法。
java判断题整理全
判断题1.调用System.gc()方法不能保证JVM立即进行垃圾收集,而只能是建议。
正确2.垃圾收集的过程在Java程序的生存期中是自动的,不需要分配和释放内存,也避免了内存泄漏。
正确3.Java数组的长度只在构造(创建)数组时指定,而在声明数组时不能指定。
正确4.成员变量和局部变量由于其所属对象生命周期不同,生存周期也不同。
正确5.数组元素没有进行显式赋值,系统根据数组声明的数据类型自动进行默认初始化。
正确6.一个源文件只能包含一个public类。
正确7.源文件命名可以依照Java语言标识符定义规定。
错误8.friendly关键字是Java语言友元类的访问控制修饰符。
错误9.类变量在该类被加载时被创建,不能用new Xxxx()创建,所有该类的实例对象共享类变量,其生存期是类的生存期。
正确10.在Java语言中,属性前不加任何访问控制修饰符则表示只允许同一包中的类访问。
正确11.类加载器加载程序运行所需要的所有类,它通过区分本机文件系统的类和网络系统导入的类增加安全性。
正确12.Java中所有参数的传递都采用值传递方式,即当传递一个参数到方法中时方法获得的是传递参数的副本。
正确13.局部变量在定义该变量的方法被调用时被创建,而在该方法退出后被撤销,其生存期和定义该变量的方法的生存期相同。
正确14.一个源文件可以包含多个类。
错误15.一个源文件中,如果没有public类,则源文件名不必与源文件中其它类名一致。
正确16.在源文件中,如果存在一个public类定义,则源文件名必须与public类名一致。
正确17.maxElements是一个成员变量,声明为:“public static final int maxElements=100;”。
正确18.任何变量在使用前都必须显式初始化。
错误19.在一个抽象类中不能定义构造方法。
错误20.类加载器加载程序运行所需要的所有类,由网络系统导入的指定类总是先被加载。
java知识点总结
java基础知识总结:一:java概述:1991 年Sun公司的James Gosling(詹姆斯·高斯林)等人开始开发名称为Oak 的语言,希望用于控制嵌入在有线电视交换盒、PDA等的微处理器;1994年将Oak语言更名为Java;Java的三种技术架构:JAVAEE:Java Platform Enterprise Edition,开发企业环境下的应用程序,主要针对web程序开发;JAVASE:Java Platform Standard Edition,完成桌面应用程序的开发,是其它两者的基础;JAVAME:Java Platform Micro Edition,开发电子消费产品和嵌入式设备,如手机中的程序;1,JDK:Java Development Kit,java的开发和运行环境,java的开发工具和jre。
2,JRE:Java Runtime Environment,java程序的运行环境,java运行的所需的类库+JVM(java虚拟机)。
3,配置环境变量:让java jdk\bin目录下的工具,可以在任意目录下运行,原因是,将该工具所在目录告诉了系统,当使用该工具时,由系统帮我们去找指定的目录。
环境变量的配置:1):永久配置方式:JAVA_HOME=%安装路径%\Java\jdk path=%JAVA_HOME%\bin2):临时配置方式:set path=%path%;C:\Program Files\Java\jdk\bin特点:系统默认先去当前路径下找要执行的程序,如果没有,再去path中设置的路径下找。
classpath的配置:1):永久配置方式:classpath=.;c:\;e:\2):临时配置方式:set classpath=.;c:\;e:\注意:在定义classpath环境变量时,需要注意的情况如果没有定义环境变量classpath,java启动jvm后,会在当前目录下查找要运行的类文件;如果指定了classpath,那么会在指定的目录下查找要运行的类文件。
Java填空题(同名10018)
Java填空题1 一个Java源程序是由若干个类组成。
2 class 是Java的关键字,用来定义类。
3 Java应用程序中有多个类时,java命令后的类名必须是包含了main 方法的那个类的名字。
4 一个Java应用程序必须且只有一个类含有main方法。
5 在一个Java应用程序中main方法必须被说明为public static void 。
6 Java中所有程序都使用方法,应用程序以main 方法开始。
7 Java源文件中有多个类,但只能有一个类是public类。
8 Java源程序编译后生成的字节码文件扩展名为class 。
9 用来标识类名、变量名、方法名、类型名、数组名、文件名的有效字符序列称为标识符。
10 Java语言规定标识符由字母、下划线、美元符号和数字组成,并且第一个字符不能是数字。
11 关键字就是Java语言中已经被赋予特定意义的一些单词,不可以把这类词作为名字来用。
12 使用关键字boolean 来定义逻辑变量。
13 关键字就是Java语言中已经被赋予特定意义的一些单词。
14 结构化程序设计的基本数据类型包括逻辑类型、整数类型、字符类型、浮点类型。
15 Java中byte型数组在内存中的存储形式是补码。
16 对于int型变量,内存分配 4 个字节。
17 对于byte型变量,内存分配1个字节。
18 对于long型变量,内存分配8 个字节。
19 对于short型变量,内存分配 2 个字节。
21 使用关键字char来定义字符变量。
23 java中,浮点型变量的类型有float和double 两种。
24 对于float型变量,内存分配 4 个字节。
25 对于double型变量,内存分配8个字节。
27 Java使用Unicode 字符集。
28 混合运算中不同类型的数据先转化为同一类型,然后运算,其中不包括逻辑类型和字符类型。
30 当把级别高的变量的值赋予级别低的变量时,必须使用强制类型转换。
java各详细总结知识点
java各详细总结知识点一、Java语法1. 数据类型Java中的数据类型分为基本数据类型和引用数据类型。
基本数据类型包括整型,浮点型,字符型和布尔型。
引用数据类型包括类、接口、数组等。
2. 变量在Java中,变量是用来存储数据的容器。
它们可以存储不同类型的数据,例如整数、浮点数、字符等。
变量分为局部变量和成员变量。
3. 运算符Java中的运算符包括算术运算符、关系运算符、逻辑运算符、位运算符、赋值运算符等。
这些运算符可以实现数据的计算和比较。
4. 控制流Java中的控制流包括顺序结构、选择结构和循环结构。
通过控制流语句,程序可以根据条件执行不同的代码块,实现不同的功能。
5. 方法方法是Java中用来组织和重用代码的一种机制。
它可以细化程序的逻辑结构,并提高代码的可读性和可维护性。
6. 数组数组是一种用来存储多个相同类型数据的容器。
在Java中,数组可以是一维的、二维的甚至多维的。
使用数组可以方便地管理大量数据。
7. 字符串在Java中,字符串是一种特殊的对象类型。
Java提供了丰富的字符串处理方法,例如字符串连接、子字符串提取、字符串比较等。
8. 输入输出在Java中,通过输入输出流可以实现与外部设备的交互。
Java提供了丰富的输入输出类和方法,可以实现文件的读写、网络通信等功能。
二、面向对象编程1. 类和对象在Java中,所有的代码逻辑都是围绕类和对象展开的。
类是一种模板,描述了对象的属性和行为。
对象是类的实例,可以根据类创建多个对象。
2. 封装封装是面向对象编程的核心思想之一。
通过封装,可以将数据和行为封装在一个对象中,避免外部直接访问对象的数据。
3. 继承继承是一种代码复用的机制,可以让子类继承父类的属性和方法。
通过继承,可以实现类与类之间的层次关系,提高代码的重用性和扩展性。
4. 多态多态是面向对象编程的另一个核心概念。
通过多态,可以使不同类的对象对同一消息作出不同的响应。
多态性可以提高代码的灵活性和可扩展性。
java中this用法总结
java中this⽤法总结1,当局部变量和成员变量重名的时候,在⽅法中使⽤this表⽰成员变量以⽰区分。
class Demo{String str = "这是成员变量";void fun(String str){System.out.println(str);System.out.println(this.str);this.str = str;System.out.println(this.str);}}public class This{public static void main(String args[]){Demo demo = new Demo();demo.fun("这是局部变量");}}分析:上⾯的类Demo中有⼀个成员变量str和⼀个局部变量str(类⽅法中的形式参数),很显然局部变量和成员变量重名,这个时候⼀般在⽅法中直接使⽤str实际上是使⽤局部变量str,对成员变量str没有任何影响,此时如果需要对成员变量做点什么,就必须使⽤this关键字。
有个问题,如果⽅法中没有str,那么在⽅法中使⽤成员变量str会是什么情况呢?实际上是⽅法内的所有操作都是针对成员变量str的。
java编程思想的84页中部有这样⼀句话:如果在⽅法内部调⽤同⼀个类的另⼀个⽅法,就不必使⽤this。
同样,在⼀个⽅法中如果没有局部变量和成员变量同名,那么在这个⽅法中使⽤成员变量也不必使⽤this,可以运⾏下⾯的代码看看。
class Demo{String str = "这是成员变量";void fun(String str1){System.out.println(str1);System.out.println(str);}}public class This{public static void main(String args[]){Demo demo = new Demo();demo.fun("这是局部变量");}}2,this关键字把当前对象传递给其他⽅法这⾥有个很经典的例⼦,就是java编程思想的85页的例⼦。
java面向对象试题及答案
JAVA面向对象一:填空1、_____ 是JVM自带的一个线程(自动运行着的程序),用于回收没有任何引用所指向的对象。
2、_____空间用于存储使用new关键字所创建的对象;_____空间用于存储程序运行时在方法中声明的所有的局部变量;_____用于存放类的信息(包括方法),方法有_____份。
3、面向对象三大特征:_____,_____,_____.4、下面是一个类的定义,请将其补充完整。
class _____ {String name;int age;Student( _____ s, int i) {name=s;age=i;}}5、Java 语言的接口是特殊的类,其中包含______常量和_______方法。
6.如果子类中的某个方法的名字、__________和参数列表与它的父类中的某个方法完全一样,则称子类中的这个方法覆盖了父类的同名方法。
7. Java 仅支持类间的单重继承,接口可以弥补这个缺陷,支持_____重继承.8. 接口中所有方法均为________和________的。
9. Java语言中,表示一个类不能再被继承的关键字是________。
10.Java语言中,表示一个类A继承自父类B,并实现接口C的语句是_________________。
11、以下代码的输出结果是________________。
int i=9;char c=’a’;char d=(char)(c+i);System.out.println(d);12.继承主要强调子类在父类的基础上取”长”补”短”,而______主要强调的是类与类之间的传输13、我们在java程序中,把关键字________加到方法名称的前面,来实现子类调用父类的方法14.java语言中,调用方法时,参数传递是_____调用,而不是地址调用15.接口是一种只含有抽象方法或______的一种特殊抽象类16.abstract方法_______(不能或能)与final并列修饰同一个类17.创建一个类就是创建一个新的数据类型,而类在java中属于_____数据类型。
Java错题合集(3)
Java错题合集(3)1、有关java实例变量,局部变量,类变量和final变量的说法,正确的是?实例变量指的是类中定义的变量,即成员变量,如果没有初始化,会有默认值。
类变量指的是⽤static修饰的属性final变量指的是⽤final 修饰的变量2、关于 Socket 通信编程,描述正确的是:()服务器端通过new ServerSocket()创建TCP连接对象服务器端通过TCP连接对象调⽤accept()⽅法创建通信的Socket对象客户端通过new Socket()⽅法创建通信的Socket对象3、访问权限控制从最⼤权限到最⼩权限依次为:public、包访问权限、protected和private 。
()错误解析:应该是:public>protected>默认(包访问权限)>private,因为protected除了可以被同⼀包访问,还可以被包外的⼦类所访问4、socket编程中,哪些socket的操作是不属于服务端操作的()?acceptlistenclose5、类⽅法中可以直接调⽤对象变量。
()错误解析:静态⽅法中不能调⽤对象的变量,因为静态⽅法在类加载时就初始化,对象变量需要在新建对象后才能使⽤6、字符界⾯下接受⽤户从键盘输⼊,需要import的包是:()java.io包7、由3 个“1”和 5 个“0”组成的 8 位⼆进制补码,能表⽰的最⼩整数()-125既然求最⼩整数,那肯定先想到负数,则最⾼位(符号位)⼀定为1,原码中肯定是1所在的位数越⾼,值越⼩,⽽补码是由原码取反加1得到的,则在补码中1所在的位数⼀定要越低,即补码为1000 0011;由补码求得原码:1111 1101=-(64+32+16+8 8、ServletConfig接⼝默认是哪⾥实现的?GenericServlet9、从内存实现或者反射的⾓度来看,关于继承的说法正确的是()。
注:此处的继承不代表能调⽤⼦类将继承⽗类的所有的数据域和⽅法10、关于java集合下列说法正确的有哪些()Collection接⼝是List接⼝和Set接⼝的⽗接⼝,通常情况下不被直接使⽤11、true、false、null、sizeof、goto、synchronized 哪些是Java关键字?gotosynchronized12、Hashtable 和 HashMap 的区别是:HashMap 是内部基于哈希表实现,该类继承AbstractMap,实现Map接⼝Hashtable 线程安全的,⽽ HashMap 是线程不安全的Properties 类继承了 Hashtable 类,⽽ Hashtable 类则继承Dictionary 类HashMap允许将 null 作为⼀个 entry 的 key 或者 value,⽽ Hashtable 不允许。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
我们学习了类的定义,我们不难理解,定义类其实就是在定义类中的成员.
成员包括成员变量和成员函数.
说到成员变量,我们很自然会想到前面提到过的局部变量,那么它们之间有什么区别呢? 首先我们定义一个People 类:
?
1 2 3 4 5 6 7 8 9 10 11 12 13 14 class People //定义一个People 类
{
String name;//姓名属性
int age;//年龄属性
char sex;
void run()//跑的方法
{
System.out.println(name+"开始跑步了.");
}
void information()
{
System.out.println("姓名:"+name+";\n 性别:"+sex+";\n 年龄:"+age+".");
}
}
然后我们从四个方面来分析下这两种变量的区别.
1.从它们的定义环境来分析,我们看一段代码.
?
1 2 3 4 5 6 class PeopleTest
{
public static void main(String[] args)
{
People kobe = new People();//创建一个People 的对象kobe String name = "jordan";
7 8 9 10 11 12 13 14 15 int age = 49;
char sex = '男';
= "KOBE";
kobe.age = 37;
kobe.sex = '男';
rmation();
kobe.run();
}
}
我们可以看到People 类中我们定义了name,age,sex 这三个变量就是成员变量;而在main 方法中我们定义了kobe,name,age,sex 这四个变量都是局部变量,那么很明显就看出了它们的不同之处:
成员变量定义在类中,整个类中都可以访问.
局部变量定义在函数,语句,局部代码块中,只在所属区域有效.
2,从它们在内在中存放形式来分析:
联系上一节以及4.3节的函数的内存分配两节我们很自然知道这两种变量的区别在于: 成员变量存在于堆内存的对象中.
局部变量存在于栈内存的方法中.
3,从它们的默认初始化来分析,我们运行上面的代码:
?
1 2 3 4 5 6 7 8 9 1class PeopleTest
{
public static void main(String[] args)
{
People kobe = new People();//创建一个People 的对象kobe String name = "jordan";
int age = 49;
char sex = '男';
= "KOBE";
kobe.age = 37;
0 11 12 13 1
4
1
5
1
6
kobe.sex = '男';
rmation();
kobe.run();
System.out.println("name:"+name+";\nsex:"+sex+";\nage:"+age+".");
}
}
结果如下:
我们再把该代码稍做修改:
?
1 2 class PeopleTest
{
3 4 5 6 7 8 9 10 11 12 13 1
4
1
5
1
6
public static void main(String[] args)
{
People kobe = new People();//创建一个People 的对象kobe String name;
int age;
char sex;
= "KOBE";
kobe.age = 37;
kobe.sex = '男';
rmation();
kobe.run();
System.out.println("name:"+name+";\nsex:"+sex+";\nage:"+age+".");
}
}
结果:
我们看出一个很显然的区别就是:
成员变量都有默认初始化值.
局部变量没有默认初始化值.
所以我们在定义成员变量时,如果我们需要特定的初始值,我们就一定要显性初始化具体值.对于局部变量,如果我们不初始化,当操作该变量时编译会提示未初始化的错误.
4.从它们的生命周期来分析,我们再对上面的代码进行一下改动:
?
1 2 3 4 5 6 class PeopleTest
{
public static void main(String[] args)
{
People kobe = new People();//创建一个People 的对象kobe String name = "jordan";
7 8 9 10 11 12 13 14 15 1
6
1
7
1
8
1
9
{
int age = 49;
char sex = '男';
System.out.println("name:"+name+";\nsex:"+sex+";\nage:"+ag e+".");//可以打印出三个局部变量的值
}
= "KOBE";
kobe.age = 37;
kobe.sex = '男';
rmation();
kobe.run();
System.out.println("name:"+name+";\nsex:"+sex+";\nage:"+age+".");//报错,找不到sex 和age 这两个变量
}
}
结果:
而当我们把最后一句打印语句注释之后的结果:
我们可以看到:
成员变量随着对象的创建而存在,随着对象的消失而消失.
局部变量随着所属区域的执行而存在,随着所属区域的结束而释放.
最后,我们再来看一个比较需要注意的地方,那就是成员变量和局部变量的同名情况. 我们把People 类修改一下:
?
1 2 3 4 5 6 7 8 9 class People //定义一个People 类
{
String name;//姓名属性
int age;//年龄属性
char sex;
void run()//跑的方法
{
System.out.println(name+"开始跑步了.");
}
10
11
12
13
14
15
16
17 void information()
{
String name = "JAMES";
int age = 29;
char sex = '女';
System.out.println("姓名:"+name+";\n性别:"+sex+";\n年
龄:"+age+".");
}
}
结果:
我们看到在打印出了局部变量的值,这是由于局部变量在栈的方法中,程序会把值直接赋值给局部变量,如果当在栈中找不到,则到堆内存中寻找指定的成员变量.这一点在以后的操作中一定要小心.
成员变量都有默认初始化值.
局部变量没有默认初始化值.。