概述
1.循环之switch语句.
switch格式:
switch(表达式或者某个变量的值){
case 值1:
语句1;
break;
case 值2:
语句2;
break;
default:
语句;
break;
}
执行流程: 首先switch接收结果
1)接收的结果和case后面的值1进行对比,成立,执行语句 1,break 结束语句;
2)值1和switch接收的结果不匹配,和值2进行比较,成立,执 行语句2, break,结束语句;
3)... 如果上面case都不匹配,执行default语句,语句n,break ,结 束语句;
注意事项:
1)关于switch中的case语句后面只能是常量,不能是变量 (体现Java是一种强类型语 言) ----前端的javascript:它里面的swtich的case是可以是变量,可以 是个常量;
2)在书写switch语句的标准结构,不忘了break,如果语句中忘了书写break,会出现一 个现象:case穿透! 在有的需求里面利用 case穿透 来完成一些需求;
3)关于switch语句的结束条件 a)要么遇见break结束 b)程序默认执行到末尾;
4)关于default语句可以在switch语句中的任何位置,不影响语句的执行流程; 不管在任何位置,只要case语句都不匹配,执行default; 如果default语句的末尾,break可以省略;
2.跳转控制语句.
break :在 looper循环或者switch中用 (中断,结束...)
continue:继续 (循环中用,结束当期循环之后,立即进入下一次循环了)
return : 结束方法用的 (很少单独使用)
结合有具体返回值类型的方法的使用(有具体返回类型,必须有结果),返回必须带回一个结果.
3.进制转换法.
十进制转化为任意进制:
使用当前十进制数据本身除基,求余,直到除到商为0为止,余数反转.
任意进制转化为十进制:
位权展开法:系数*基数的权次幂相加;
4.for循环与while循环的区别?
共同点:都是能够体现循环思想,解决代码冗余问题
不同点: 1)格式不同 ;
2)使用场景不同 for循环(普通for循环),明确循环次数优先采用for (实际开发中for使用很频 繁:遍历数组,获取数组的元素) ;
while循环: 不明确循环次数使用while循环
3)从内存角度是否节省内存 for循环的这种格式,比较节省内存资源,当for循环结束,里面的变量被释放了, 这个变量作用域就在 for(初始化语句;条件表达式;控制体语句){ 循环体语句; } while循环,相对for循环,比较消耗内存,当while循环结束,依然能够访问变量.
5.switch语句后面的表达式可以是什么数据类型?
可以跟的基本数据类型 byte,short ,int ,char;
jdk5以后,可以枚举类型;
jdk7以后,可以String类型;
6.while死循环.
死循环:利用死循环完成一些需求,死循环中肯定需要使用逻辑判断; 当达到某种条件的时候,应该结束死循环;
典型案例:猜数字游戏
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
int a =0;
int count = guess(a);
System.out.println(count+"次猜中了!!!");
}
public static int guess(int a){
int b =(int)( Math.random()*100+1);
int count=0;
System.out.println("请输入数据a:");
while(true){
count++;
Scanner sc = new Scanner(System.in);
int c = sc.nextInt();
if (b>c){
System.out.println("不好意思,你猜小了!!");
}else if(b<c){
System.out.println("不好意思,你猜大了!!");
}else if(b == c){
System.out.println("恭喜你,猜对了!!!");
break;
}else{
System.out.println("输入数据不合法!!");
}
}
return count;
}
}7.java中定义方法的格式:有具体返回值类型的方法的定义以及调用.
定义: public static 返回值类型 方法名(形参数据类型 形参,形参数据类型 形参...){
业务逻辑;
return..;
}
调用: 返回值类型 变量 = 方法名(实参,实参....);
8.没有返回值类型的方法的定义以及调用.
定义: public static void 方法名(形参的数据类型 形参,形参的数据类型 形参...){业务逻辑;输出结果;}
调用格式:单独调用方法名(实参,实参.....);
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入数据n:");
int n = sc.nextInt();
cheng(n);
}
public static void cheng(int a){
for (int i = 1;i<=a;i++){
for(int j =1;j<=i;j++){
System.out.print(i+"*"+j+"="+(i*j)+"t");
}
System.out.println();
}
}
}9.JVM内存分配有那些,有什么作用?
栈内存:存储局部变量用的这个内存区域.
堆内存: new出来的对象存储在这个区域.
方法区: 字节码文件区域----->方法调用过程需要加载类;
static区域---------->main方法就是被static修饰的;
常量池------->常量的都是在常量池.
寄存器
本地方法区
10.什么是方法重载?
为了某个功能扩展性,多个方法方法名可以相同(完全相同),参数列表不同,与 返回值无关;
参数列表不同: 参数的类型不同,参数个数不同,参数的顺序不同.
11.什么是数组,数组的定义格式有那些?
定义:数组是一种容器,容器只能存储同一种类型的元素.
动态初始化:自己定义数组的长度,数组的元素有系统(jvm)默认分配;
格式: 数据类型[] 数组名称 = new 数据类型[数组长度] ; 推荐第一 种
数据类型 数组名称[] = new 数据类型[数组长度] ;
int[] arr = new int[80] ;
int arr[] = new int[80];
静态初始化:直接我们自己给定的了元素内容,数组的长度由系统默认分配 .
数据类型[] 数组对象名 = {元素1,元素2,元素3.....} ; 推荐的写法
数据类型 数组对象名[] = {元素1,元素2,元素3.....} ;
int[] arr = {1,2,3} ;
int arr[] = {1,2,3} ;
在数组中有一个特有的属性:length
数组名称.length:获取数组长度
数组中的最大索引值: 数组名称.length-1
12.定义一个数组,对其进行遍历,逆序.
import java.util.Scanner;
public class Test1 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入数据a:");
int a = sc.nextInt();
System.out.println("请输入数据b:");
int b = sc.nextInt();
System.out.println("请输入数据c:");
int c = sc.nextInt();
System.out.println("请输入数据d:");
int d = sc.nextInt();
System.out.println("请输入数据e:");
int e = sc.nextInt();
int[] arr={a,b,c,d,e};
System.out.println("遍历数组为:");
bianLi(arr);
System.out.println("逆序数组为:");
ni(arr);
}
public static void bianLi(int[] arr){
System.out.print("[");
for(int i = 0;i < arr.length;i++){
if(i== arr.length-1){
System.out.println(arr[i]+"]");
}else{
System.out.print(arr[i]+", ");
}
}
}
public static void ni(int[] arr){
for(int i = 0;i < arr.length/2;i++){
int temp = arr[i];
arr[i] = arr[arr.length-1-i];
arr[arr.length-1-i] = temp;
}
bianLi(arr);
}
}
13.自定义一个数组,对其进行冒泡排序.
public class Test1 {
public static void main(String[] args) {
int[] arr= {12,456,75,25,64,258,456};
System.out.println("遍历数组:");
bianLi(arr);
System.out.println("对数组排序后为:");
maoPao(arr);
}
public static void bianLi(int[] arr){
System.out.print("[");
for(int i = 0;i < arr.length;i++){
if(i== arr.length-1){
System.out.println(arr[i]+"]");
}else{
System.out.print(arr[i]+", ");
}
}
}
public static void maoPao(int[] arr){
for(int i = 0;i < arr.length-1;i++){
for(int j=0;j < arr.length-1-i;j++){
if(arr[j] > arr[j+1]){
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
bianLi(arr);
}
}14.面试题 in[] arr = new int[2];完成了那些事情?
首先在栈内存中给int[] arr开辟了一个空间;
其次new int[2]在堆内存中申请了一个空间,
系统堆数组的内容进行初始化,并且数组中元素默认为0;
系统默认初始化完毕,产生了一个堆内存空间地址值;
int[2]将地址值赋值给了arr,而arr指向内存空间地址;
15.形式参数分别为基本类型和引用类型(数组 的情况)的不同情况？
形式参数为基本类型: 当形参传递时不会影响实际参 数.
形式参数为引用类型:当形参传递时会改变实际参数. (String当做基本类型对待)
类与对象
1.面向对象的思想特点? 三大特征?
思想特点:
更符合生活中的思想行为习惯
让复杂的事情简单化
让我们从执行者变成指挥者
三大特征:
封装 继承 多态
2.局部变量和成员变量的区别?
位置不同:局部变量存在于方法块或者参数列表中,
而 成员变量在方法外的类中.
周期不同:局部变量的周期随着代码块的运行而产生, 结束运行则局部变量消失.
成员变量是随着创建对象而产生,跟随对象 的消失而消失.
初始值不一样:局部变量没有默认初始值.
而成员变量 具有默认初始值.
3.创建一个类对象的格式以及如何访问成员变量,访问 成员方法
创建对象格式:
类名 变量名 = new 类名();
访问成员变量: 变量名.成员变量 = " ";
访问成员方法: 变量名.成员方法();
实例:
学生事物 属性：姓名，年龄，性别，发型
行为：吃饭，抽烟，打游戏，学习Java
//学生类
public class Student {
String name;
int age;
String sex ;
String hairStyle;
public void eat(String e){
System.out.println("正在吃"+e);
}
public void smoke(String s){
System.out.println("正在抽"+s);
}
public void play(String p){
System.out.println("正在打"+p);
}
public void study(){
System.out.println("正在学习Java");
}
}
//学生测试类
public class StudentTest {
public static void main(String[] args) {
Student s = new Student();
s.name = "张三";
s.age = 23;
s.sex = "男";
s.hairStyle = "锡纸烫";
System.out.println("我的名字是"+s.name+",我的年龄是"+s.age+
",我是"+s.sex+"性,我的发型是"+s.hairStyle);
s.eat("午饭");
s.smoke("中华");
s.study();
s.play("和平精英");
}
}键盘录入长方形的长和宽，长方形事物的行为 计算长方形的周长和面积;
//长方形类
public class Rectangle {
public void circumference(double l,double w){
double c = (l+w)*2;
System.out.println("长方形的周长为"+c);
}
public void area(double l,double w){
double a = l*w;
System.out.println("长方形的周长为"+a);
}
}
//长方形测试类
import java.util.Scanner;
public class RectangleTest {
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
System.out.println("录入长方形的长l:");
double l = s.nextDouble();
System.out.println("录入长方形的宽w:");
double w = s.nextDouble();
Rectangle rectangle = new Rectangle();
rectangle.area(l,w);
rectangle.circumference(l,w);
}
}
3.private关键字的特点?
1)被private修饰的成员变量以及成员方法只能在本类中访问;
2)可以修饰成员变量也可以成员方法,就是为了外界不能直接访问;
3)被private修饰的成员变量/成员方法可以间接的通过公共(setXXX()/getXXX()公共方法)的方法访问;
private实例:
//学生类
public class Student {
private String name;
private int age;
private String sex ;
private String hairStyle;
public void setName(String n) {
name = n;
}
public String getName(){
return name;
}
public void setAge(int a){
age = a;
}
public int getAge(){
return age;
}
public void setSex(String s){
sex = s;
}
public String getSex(){
return sex;
}
public void setHairStyle(String h){
hairStyle = h;
}
public String getHairStyle(){
return hairStyle;
}
public void show(){
System.out.println("我的姓名是"+name+",我是"+sex+"性,我的年纪是"+age+"岁,我的发型是"+hairStyle);
}
public void eat(String e){
System.out.println("正在吃"+e);
}
public void smoke(String s){
System.out.println("正在抽"+s);
}
public void play(String p){
System.out.println("正在打"+p);
}
public void study(){
System.out.println("正在学习Java");
}
}
//学生测试类
public class StudentTest {
public static void main(String[] args) {
Student s = new Student();
s.setName("王麻子");
s.setSex("男");
s.setAge(32);
s.setHairStyle("锡纸烫");
s.show();
s.eat("午饭");
s.smoke("中华");
s.study();
s.play("和平精英");
}
}最后
以上就是感动猫咪为你收集整理的JAVA第二周总结类与对象的全部内容，希望文章能够帮你解决JAVA第二周总结类与对象所遇到的程序开发问题。
如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。
![[Java] 为什么要定义接口](/uploads/reation/bcimg9.png)
发表评论 取消回复