生物做实验的网站,自适应网站建设,15年做那个网站致富,北京注册公司地址有什么要求一.数据类型 1.基本数据类型 基本数据类型 大小 范围 byte(字节整型) 1byte(8bit) -128(-2^7)~127(2^7-1) short(短整型) 2byte -2^15~2^15-1 int(整型) 4byte -2^31~2^31-1 long(长整型) 8byte -2^63~2^63-1 float(单精度浮点数) 4byte -3.4E38~3.4E38 double(双精度浮… 一.数据类型 1.基本数据类型 基本数据类型 大小 范围 byte(字节整型) 1byte(8bit) -128(-2^7)~127(2^7-1) short(短整型) 2byte -2^15~2^15-1 int(整型) 4byte -2^31~2^31-1 long(长整型) 8byte -2^63~2^63-1 float(单精度浮点数) 4byte -3.4E38~3.4E38 double(双精度浮点数) 8byte ~1.7E308~1.7E308 char(字符型) 2byte 表示一个字符或数字0~65535 boolean(布尔型) 1byte truefalse 1long型在声明时如果声明的数值大于int的范围需要在末尾加L或者l。如:long l22222222222L; 2float型在赋值时需要在末尾加F或者f。如:float f2.0f; 3double型在进行计算时会出现舍入误差的情况。 4转义字符 1 charc\n;//换行 2.引用类型 1当多个字符连在一起就不是基本数据类型而是一个类就叫引用类型1 String strhelloWorld; 2字符串类型基本数据类型字符串类型 3.类型转换 3.1.自动转换 1小范围的数据类型的值或者变量可以赋给大范围的数据类型的变量2不同类型的值在计算时会自动转换成最大范围的数据类型 3byte、short、int、char不会相互转换但是三者在运算时都会转换成int类型来计算 3.2.强制转换 小数据类型 变量名 (小数据类型) 大类型数据变量或值 1 doubled2.7; 2 int i(int)d;//把大范围类型赋给小范围类型 要强制转换 二.运算符 1.算术运算符 、-、*、/、%(取余)、(自增)、--(自减)、、 1除法:整数在做除法运算时去除小数部分保留整数部分。 2取余:取余结果的符号于被取余数一致;如果被取余数小于被取余数结果等于被取余数 3后置自增自减:先做运算再自增自减;前置自增自减:先增自减再赋值 2.关系运算符 、、、、、! 3.逻辑运算 (与)、||(或)、!(非) 变量A 变量B AB A||B A!B FFFFT FTFTT TFFTF TTTTF 4.赋值运算 1 intsum10; 2 sum2;// sumsum2 3 sum*3;//sumsum*3 5.字符串拼接运算 1 String str111 ;//先运算再拼接 2 String str2111;//先拼接再运算 100100100100100100 6.三目运算符 1 boolean 表达式 ? 表达式1:表达式2; 三.流程语句 1.if条件语句 1 if(布尔类型的表达式或者值){ 2 代码1; 3 }elseif(布尔类型的表达式或者值){ 4 代码2; 5 }else{代码3; 6} 2.swtich case选择语句 1 switch(表达式){//byte,short,int,long ,char,String 2 case 值1:代码1;break; 3 case 值2:代码2;break; 4 case 值3:代码3;break; 5 .. 6 default:代码; 7} 3.循环语句 循环语句四要素:1初始化一个变量;
2布尔类型的表达式或者值;
3循环体;
4步进表达式;3.1.while循环 1 1初始化一个变量 // 用来控制循环的开始或者结束 2 while(2布尔类型的表达式或者值){ 3 3循环体; 4 4步进表达式;//去改变变量的值 5} 6 //执行流程:1-2-3-4 2-3-4 2-3-4 2不满足条件时跳出循环 3.2.do-while循环 1 1初始化一个变量 2 do{ 3 2循环体; 4 3步进表达式;}while(4布尔类型的表达式或者值) 5 //执行流程:1-2-3-4 2-3-4 2-3-4 不满足时跳出 do-while无论如何都会执行一次 3.3.for循环 1 for(1初始化变量;2布尔类型表达式或者值;4步进表达式){ 2 3循环体; 3} 4 //执行流程:1-2-3-4 2-3-4 2不满足时跳出 3.4.循环的嵌套 1break:直接跳出循环循环语句不会再执行 2continue:跳出本次循环继续执行循环 四.方法 静态方法:把一个功能单独拎出来放在方法里需要使用时再去调用1 权限修饰符 static 返回值类型 方法名(){ 2 return; 3} 1.方法的调用 1 方法名(); 2 类名.方法名; 3 对象名.方法名; 2.方法的形式 2.1.void 1 publicstaticvoidtest(){ 2 }//没有返回值的方法用void表示 2.2.int 1 publicstaticinttest(){ 2 return_; 3 }//有返回值的方法用int表示 2.3.void ___(int a,int b) 1 publicstaticvoidtest(inta,intb){ 2} 2.4.double ___(double a,int b,char c) 1 publicstaticdoubletest(doublea,intb,charc){ 2 returnabc; 3 }//有返回值也有参数的方法 1在有返回值的方法中可以去定义与方法返回值类型相匹配的变量去接收
2也可以直接打印3传参时类型顺序要和形参顺序一致3.方法的重载 1 //方法的重载同名不同参 不同参:参数类型和数量 2 publicstaticvoidtest(inti,intj){ 3 intsumij; 4 System.out.println(sumsum); 5} 6 publicstaticvoidtest(inta,intb,intc){ 7 System.out.println(abc); 8} 9 publicstaticvoidtest(doublea,intc){ 10 System.out.println(ac);}publicstaticvoidmain(String[]args){ 11 //重载方法的调用:格数传递的参数数量和类型 来判断调用哪个方法 12 test(10,11);//21 13 test(10,11,12);//33 14 test(3.14,12);//15.14 15 } 五.数组和二维数组 数组是一种数据结构是相同类型元素的一个集合。数组中的元素通过下标来获取。下标是0开始最 大为数组的长度-1 1.数组的定义 1.1数组的声明方式 1 数据类型[] 数组名new 数据类型[数组的长度]; 1 数据类型[] 数组名new 数据类型[]{1,2,3,4,5}; 1 数据类型[] 数组名{6,7,8,9}; 1.2数组元素的访问 1 格式:数组名[下标] 2 System.out.println(arr[0]);//访问第1个元素 3 System.out.println(arr[1]);//访问第2个元素 2.数组的遍历 一个一个的获取数组中的元素1 //数组长度的获取: 数组名.length 2 int[]arrnewint[]{5,2,7,8,9,56,65,7,5,1,54,5};//获取数组的长度冒泡排序 3 intlengtharr.length; 4 System.out.println(arr数组的长度:length); 2.1.for循环遍历 1 for(inti0;iarr.length;i){ 2 System.out.print(arr[i]\t); 3} 2.2.增强for循环遍历(jdk1.8) 1 for(inti0;iarr.length;i){ 2 System.out.print(arr[i]\t); 3} 2.3.数组元素的交换 1 nt temparr[0];//temp为临时变量存储要互换元素的值 2 arr[0]arr[1]; 3 arr[1]temp; 4 for(inti:arr){ 5 System.out.print(i\t); 6} 3.冒泡排序 1 publicstaticvoidbubSort(){int[]arr{21,12,33,5,1}; 2 for(inti0;iarr.length-1;i){//这个循环代表需要排序次数。-1表示:5个元素只需要 排4次 3 for(intj0;jarr.length-1-i;j){//代表比较次数。-1:五个元素只需比较4次-i: 每排一次都能确定一个最值所以比较次数会减少 4 if(arr[j]arr[j1]){//元素交换。如果前面的值比后面的小则交换位置 5 inttemparr[j]; 6 arr[j]arr[j1]; 7 arr[j1]temp;} 8} 9} 10 } 4.数组的复制 1 publicstaticvoidarrCopy(){ 2 int[]arrnewint[]{5,6,7,8,9,10}; 3 int[]arr2newint[6];//{0,0,0,0,0} 4 System.arraycopy(arr,0,arr2,0,6); 5 System.out.println(Arrays.toString(arr2)); 6} 7 publicstaticvoidarrCopy2(){ 8 int[]arrnewint[]{5,6,7,8,9,10}; 9 int[]arr2Arrays.copyOf(arr,15); 10 System.out.println(Arrays.toString(arr2)); 11 } 1src:源数组 2srcPos:源数组的起始下标 3dest:目标数组 4destPos:目标数组的起始下标 5length:复制的长度 6original:源数组 7newLength:复制的长度如果超过了源数组的长度不会越界是用来初始化一个新的数组的 5.二维数组 5.1.二维数组的声明方式 1 数据类型[][] 数组名 new 数据类型[一维数组的个数][一维数组的元素个数]; 1 数据类型[][] 数组名 new 数据类型[一维数组个数][]; 1 数据类型[][] 数组名new 数据类型[][]{{1,2},{3,4},{5,6,{7,8}} 1 数据类型[][] 数组名{{ {1,2,3},{4,5,6},{7,8,9} }; 5.2.二维数组的遍历 1 for(inti0;iarr4.length;i){ 2 int[]temparr4[i]; 3 for(intj0;jtemp.length;j){ 4 System.out.print(temp[j]); 5} 6} 六.面向对象 1.面向对象概述 1对象:万物皆对象客观存在的事物都是对象
2类:类是对现实生活中的一类具有共同属性和行为的事物的抽象是具有相同属性和行为的一组对
象的
集合
3对象的属性:对象具有的各种特征每个对象的每个属性都拥有特定的值
4对象行为:对象能够干什么2.类的定义 类是由属性和行为组成。 属性:在类中通过成员变量来体现。(类中方法外的变量) 行为:在类中通过成员方法来体现。(不用static修饰的方法) 3.对象的使用 3.1.创建对象(实例化) 1 类名 对象名new 类名(); 3.2.使用对象 1 对象名.属性名值; 2 对象名.成员方法名(); 4.成员变量和局部变量的区别 成员变量:定义在类中方法外的变量
局部变量:在类的方法中定义的变量区别 成员变量 局部变量 代码中位置 类中方法外 方法里 内存中位置 堆内存 栈内存 生命周期不同 随对象存在而存在随对象消失 随方法调用而存在方法执行完 而消失 消失 初始化值不同 有默认的初始化值 没有默认值使用前必须初始化 5.this关键字 1表示当前对象的引用 2当局部变量名和成员变量名一样时使用this可以区别局部变量和成员变量 3方法被哪个对象调用this就指代的时哪个对象。 4在成员方法中可以使用this.方法名调用其它的成员方法 6.构造方法 1在创建对象时会自动调用构造方法 2如果没有定义构造方法系统将给出一个默认的无参构造方法(看不见的)。 3如果定义了构造方法系统将不再提供默认的构造方法默认的无参构造方法将会被覆盖 4可以使用方法的重载去声明有参或者无参的多个构造方法。 5在构造函数中可以使用this(参数列表)调用 另一个构造函数。注:this()必须放在第一行 七.继承 1.继承的概念 继承是面向对象的三大特征之一。通过继承使得子类对象具有与父类相同的属性相同的行为。并
且子类可以直接访问父类中的非私有的属性和行为1.1.为什么要用继承 1多个类存在相同的属性和行为时将这些内容抽取到单独的一个类中那么多个类无需再定义这些 属性和行为只需继承那一个类即可 2子类要继承父类中的属性那么父类中的属性就不能用private修饰 1.2.继承的设计思路 1找出几个类的共性 2抽象出父类 3判断是否有is-a的关系 1.3.继承的格式 通过extends关键字可以声明一个类继承自另一个类 1.4.继承的特点 1单一性:一个类只能继承一个父类不能继承多个父类 2传递性:类1--继承--类2类2--继承--类3 类1同时拥有类2和类3中的公有属性 3优点:提高了代码的复用性;使类与类之间产生了联系是多态的前提 4缺点:正因为让类与类之间产生了关系类的耦合性也增加了。当父类变化的时候子类也不得不 跟着变化 5子类可以访问父类非私有的属性但父类不能访问子类特有的属性 2.super关键字 2.1.当子类成员变量与父类中的成员变量同名 如果父类变量与子类变量出现同名的情况此时在子类中访问该变量时是访问的是子类中变量的 值。如果此时需要访问到父类变量的值时需要使用super关键字 1 super.父类成员变量名 2.2.当子类成员方法名与父类中的成员方法同名 如果在子类中想要调用父类中同名的方法名使用super.方法名()就可以调用父类中的方法 1 super.方法名() 2.3.super在子类构造方法中的使用 在创建子类对象时默认会先去调用父类的无参构造方法再去执行完子类本身的无参构造方法1通过super();可以去调用父类无参构造方法 2如果父类中没有无参构造方法只有有参构造方法我们可以在父类中创建一个无参构造方法或者 使用super(参数列表);根据父类有参构造方法中的参数去传递相应的参数列表来进行调用
2.4.为什么要去先执行父类的构造方法
构造方法在创建对象的时才会去调用所以调用了父类构造方法相当于去创建了父类的对象。之所以
我们能访问到一个类中的属性是因为我们创建了该类对象在堆中就会开辟一个空间存储类的属性
信息并且把地址赋给引用。此时我们就可以通过引用去访问类中属性了。所以创建父类对象相当于
去堆中去开辟空间存储父类的属性信息此时子类拿到该空间地址就可以访问了八.封装 1.封装的概念 封装可以被认为是一个保护屏障防止该类的代码和数据被其他类随意访问。要访问该类的数据必
须通过指定的方式。适当的封装可以让代码更容易理解和维护也加强了代码的安全性2.封装的使用 2.1.使用private关键字对成员变量进行修饰 private的使用:1private是一个权限修饰符代表最小权限 2可以修饰成员变量和成员方法 3被private修饰后的成员变量和成员方法只能在本类中访问 2.2.对需要进行赋值或者获取的成员变量提供对应的getter和setter方法 2.2.1.set方法格式 1 public void setXXX(参数类型 参数名){ 2 this.成员变量名参数名;//参数名和成员变量名一致时要使用this来区分 3} 2.2.2.get方法格式 1 public 返回值类型 getXXX(){ //返回值类型和成员变量类型一致 2 retrun 成员变量; 3} 3.标准的JavaBean JavaBean时java语言在编写类的时候要遵守的一种标准规范 1 publicclassClassName{ 2 //成员变量 3 //无参构造方法(必须) 4 //有参构造方法(依情况而定) 5 //成员方法 6 //set和get方法(必须) 7} 九.权限修饰符 权限修饰符 同一个类 同一个包 不同包的子类 不同包的非子类 private(私有) Y N N N default(默认) Y Y N N protected(受保护 的) YYYN public(公开) Y Y Y Y 十.重写 子类中出现了和父类一模一样(名字参数列表一模一样)的方法。延续父类的功能又在此基础上增加 了自己的特有内容进行功能扩展增强 1 publicclassPhone{ 2 publicvoidsendMessage(){ 3 System.out.println(发短信); 4} 5 publicvoidcall(){ 6 System.out.println(打电话); 7} 8} 1 publicclassSmartPhoneextendsPhone{ 2 Override//对父类的成员方法进行重写 3 publicvoidsendMessage(){ 4 super.sendMessage();//通过super调用了父类中的方法 5 System.out.println(用微信发信息); 6} 7 Override//对父类的成员方法进行重写 8 publicvoidcall(){ 9 super.call(); 10 System.out.println(打视频电话); 11 } 12 //测试 13 publicstaticvoidmain(String[]args){ 14 //创建子类对象 15 SmartPhone spnew SmartPhone(); 16 //调用从父类重写过来的方法 17 sp.call(); 18 sp.sendMessage(); 19 } 20 } 1Override注解的作用:1.表示该方法是重写的是父类中的方法。 2.检查重写过后的方法是否符合要求 2私有的方法不能被重写 3子类重写父类方法过后访问权限不能比父类低(Publicprotecteddefault) 4被final修饰的成员方法也不能进行重写 十一.final、stiatc、代码块 1.final关键字 1被final修饰的变量表示该变量的值不可被修改 2被final修饰的类无法被继承 3被final修饰的成员方法无法被子类重写 2.Static关键字 static可以用来修饰成员方法成员变量表示该属性为静态属性。 2.1.被类的所有对象共享访问
只要其中一个对象去改变了静态country的值那其它对象访问到country的值就是被改变后的值。所 以再次说明使用static修饰的属性是被共享的
2.2.可以直接使用类名进行访问 2.3.static访问的特点
1在静态方法中不能直接访问到非静态的属性但可以访问到静态属性。
2在非静态方法中能访问到静态方法3加载类时就先会加载静态的属性此时非静态的属性还没有加载必须创建对象过后才会加载
因此无法去访问非静态的属性。
4非静态属性能访问静态属性是因为此时静态属性已经加载完了所以可以访问2.4.stiact使用场景 方便在没有创建对象的情况下来进行调用。也就是说被static关键字修饰的变量或者方法不需要创建 对象去调用直接根据类名就可以去访问 3.代码块 3.1.静态代码块 类加载的时候去执行里面的代码。3.2.构造代码块 创建对象的时候去执行先于构造方法执行十二.多态 多态性是面向对象编程的又一个重要特征它是指在父类中定义的属性和方法被子类继承之后可以
具有不同的数据类型或表现出不同的行为1.多态的前提 1有继承/实现关系; 2方法重写 3父类引用指向子类对象(向上转型 1 //狗就是狗 2 Dog dognew Dog(); 3 4 5 //狗是动物 (向上转型) 6 Animal animalnew Dog(); 7 //表示 狗是动物的类型 2.多态访问的特点 访问成员变量:编译看父类运行看父类。
访问成员方法:编译看父类运行看子类3.多态的特点 1优点:提高了程序的扩展性
2缺点:不能使用子类特有的属性和方法4.多态的转型 1向上转型:父类引用指向子类对象
2向下转型:父类引用转换为子类对象。可以调用子类中特有的方法。前提是先要向上转型十三.抽象类 如果一个方法不能具体地表现出它的行为那么方法是抽象的1.抽象方法的定义 使用abstract关键字去修饰的一个方法表示该方法是抽象方法 1 public abstract 返回值类型 方法名(参数); 1.1.抽象方法的三个特征 1抽象方法没有方法体只声明 2抽象方法必须存在于抽象类中 3不能使用private和static修饰 使用abstract去修饰抽象方法时不能使用private修饰因为抽象方法要执行就必须使用子类去重 写使用private将无法重写就没有了意义 2.抽象类的定义 使用abstract关键字修饰的类为抽象类 1 public abstract class 类名 2.1.抽象类的特征 1如果类里面有一个方法时抽象的那么该类就必须是抽象类 2抽象类中即可以有抽象方法也可以有具体的方法 3抽象类不能实例化就是不能使用new去创建对象 4抽象类中可以有构造方法用于子类创建对象时初始化父类成员 5抽象类的子类必须重写抽象父类中中的所有抽象方法 6如果抽象类的子类也是抽象类则不需要重写父类中的抽象方法 十四.接口 接口是一个公共的规范只要符合规范标准大家都可以使用就像一个类一样一个接口也能够拥
有方法和属性1.接口的特点 1接口相当于指明了一个类必须要做什么和不能做什么相当于类的蓝图
2一个接口就是描述一种能力2.为什么要使用接口 1接口提供了一个公共的规范 2接口弥补了Java不能多继承这个局限 3接口可以实现解耦 3.接口的使用 使用interface关键字 1 public interface 接口名{} 3.1.接口的属性特点 1接口中声明的变量默认都是public static final修饰. 2接口中声明的方法默认都是public abstract修饰的抽象方法,因此没有方法体.(jdk1.8)后是可以在接 口中定义非抽象方法,使用default去修饰) 3在接口中没有构造方法 3.2.实现一个接口 使用implements关键字实现类必须重写接口里面所有的抽象方法 1 class 类 implements 接口名{ 2 //实现接口中声明的抽象方法 3} 4.接口和类的区别 1类只能单继承只能继承一个父类
2接口可以多实现一个接口可以实现多个接口
3一个类可以继承一个父类同时实现多个接口十五.内部类 1在类中又声明一个类该类为内部类
2在内部类中可以直接访问到外部类中的成员属性(包括私有属性)
3外部类如果想要访问到内部类里面的属性就必须创建内部类对象1.成员内部类(类中方法外) 1 publicclassOuterClass{ 2 //成员变量 3 String name; 4 intage; 5 //成员方法 6 publicvoidtest(){} 7 //成员内部类 8 publicclassInnerClass{ 9 String innerName; 10 intinnerAge; 11 publicvoidprint(){ 12 System.out.println(我是成员内部类!); 13 } 14 } 15 publicstaticvoidmain(String[]args){ 16 //如何去创建内部类对象? 17 //1.先创建外部类对象 18 OuterClass outernew OuterClass(); 19 //2.创建内部类对象 20 //格式 外部类名.内部类名 引用外部对象引用.new 内部类名(); 21 OuterClass.InnerClass innerouter.new InnerClass(); 22 //调用内部类的属性 23 inner.print(); 24 } 25 }
2.局部内部类(方法中)
不能有修饰符
1 publicclassOuterClass{ 2 publicvoidtest(){ 3 //局部内部类 4 classInnerClass{
5 publicvoidtest(){ 6 System.out.println(我是局部内部类); 7} 8 9 //在方法中去创建内部类对象 10 InnerClass inner new InnerClass(); 11 inner.test(); 12 } 13 publicstaticvoidmain(String[]args){ 14 OuterClass outer new OuterClass(); 15 outer.test(); 16 } 17 }
3.匿名内部类 1 publicclassOuterClass{ 2 publicstaticvoidmain(String[]args){ 3 //匿名内部类 4 USB unew USB() { 5 Override 6 publicvoidread(){ 7 System.out.println(读取); 8} 9 Override 10 publicvoidwrite(){ 11 System.out.println(写入); 12 } 13 }; 14 u.write(); 15 u.read(); 16 } 17 } 十六.String 1.String的不可变性 String字符串是由一个个字符组成 1 String strJava; 实质上底层使用的是一个char[]类型数组进行存储 1 char[]value{J,a,v,a}; String的不可变性是指:不是在原有的存储hello的空间中去改变String的值而是重新开辟了一个空 间去存储新的值str引用并指向了新开辟的空间 2.String字符串的部分声明方式 2.1.直接初始化 1 String str1我是一个字符串; 2 System.out.println(str2);//我是一个字符串 2.2.通过构造器初始化 1 //创建String对象通过构造器的方式进行初始化,参数为字符串。 2 String str2new String(我是一个字符串); 3 System.out.println(str2);//我是一个字符串 4 //通过构造器的方式进行初始化,参数为字符型数组 5 byte[]b{J,a,v,a}; 6 String str4new String(b); 7 System.out.println(str4);//Java 3.字符串的比较 3.1.使用比较 比较的是地址 因为不同的字符串的指向的字符串都在常量池中并且指向的是同一个空间所有 地址相同 3.2.使用equals方法比较 equlas在字符串的比较中比较的是字符串的内容 4.StringBuffer StringBuufer是可以存储和操作字符串即包含多个字符的字符串数据。String类是字符串常量是不 可更改的常量。而StringBuffer是字符串变量它的对象是可以扩充和修改的 4.1.StringBuffer的初始化 1 StringBuffer buffernew StringBuffer(Java); 2 System.out.println(buffer);//Java 4.2.StringBuffer中常用方法 4.2.1.append方法:拼接字符串 1 StringBuffer buffernew StringBuffer(hello); 2 buffer.append(world); 3 System.out.println(buffer);//helloworld 4.2.2.toString:转换为String类型 1 String strbuffer.toString(); 2 System.out.println(str); 4.2.3.charAT: 1 System.out.println(buffer.charAt(0)); 4.2.4.setChar:替换指定下标的字符 1 buffer.setCharAt(1,B); 2 System.out.println(buffer); 4.2.5.reverse:翻转 1 StringBuffer buffer2new StringBuffer(helloworld); 2 StringBuffer reverse buffer2.reverse(); 3 System.out.println(reverse); 4.3.StringBuffer中的比较 StringBuffer中没有去重写equals方法所以是在比较地址 1 StringBuffer buffernew StringBuffer(Java); 2 StringBuffer buffer2new StringBuffer(Java); 3 System.out.println(bufferbuffer2);//false在堆中创建地址不同 4 System.out.println(buffer.equals(buffer2));//false 4.4.StringBuffer和StringBuilder的区别 StirngBuilder和StringBuffer的操作可以说几乎一模一样。但是StringBuffer是线程安全 StringBuilder是线程不安全
