Day5:
do-while循环语句的格式
初始化语句;
do{
循环体语句;
步长语句
}while(条件表达式) ;
do-while循环语句和for,while循环的最大的区别就是:循环体至少执行一次(条件不满足的情况)
for,while,do-while循环
开发中:常用for循环,其次是while循环,do-while使用很少,以后在java源码中会见到这个语句!
//连续输出hello
class DoWhileDemo{
public static void main(String[] args){
int i = 6 ;
do{
System.out.println("hello") ;
i++ ;
}while(i<=5) ;
}
}
for循环的嵌套:
for循环语句作为循环体语句;
for(初始化语句;条件表达式;步长语句){
//循环体语句
for(初始化语句;条件表达式;步长语句){
循环体语句;
}
}
举例4行5列的*
class WangDemo{
public static void main(String[] args){
for (int x=0 ; x<4 ; x++){//控制的是行数
for (int y = 0 ; y<5 ; y++){//控制的是列数
System.out.print("*");
}
System.out.println();
}
}
}
99乘法表:
public class Demo {
public static void main(String[] args) {
for (int i = 1; i <=9; i++) {
for (int j = 1; j <=i; j++) {
System.out.print(j+"*"+i+"="+(i*j)+"\t");
}
System.out.println();
}
}
}
跳转控制语句:
break:
结束当前循环
break应用场景:只能switch语句或者循环语句中使用!
情况1:中断结束单层循环
情况2:中断结束多层循环(早期使用)
continue
结束当前循环,立即执行下一循环
return
结束当前方法
方法
方法的概念:
方法:就是使用{}包起来的内容,给{}独立的代码块起一个名字,以便于复用
方法和方法是平级关系,不能再一个方法中定义另一个方法
定义方法的格式:
情况1:有具体的返回值类型
情况2:没有具体的返回值类型
有返回值类型的格式:
权限修饰符 静态修饰符 返回值类型 方法名(变量1,变量2,......)
class FunctionDemo{
public static void main(String[] args){
int a = 10 ;
int b = 20 ;
int result = getSum(a,b);
System.out.println("两个数据之和是:"+result) ;
}
}
public static int getSum(int x,int y){
int result = x + y ;
return result ;
}
}
没有返回值类型的格式:
权限修饰符 静态修饰符 void 方法名(变量1,变量2......)
要么输出结果要么相关其他业务功能 ,没有return关键字
Day6:
数组的概念:
数组是一种"容器" 可以存储同一种类型的元素的一种"容器"
数组的格式:
数据类型[] 数组名称; int[] arr
数据类型 数组名称[] ; int arr[]
数组的动态初始化:
数据类型[] 数组名称 = new 数据类型[数组长度] ; int[] arr = new int[length]
数据类型 数组名称[] = new 数据类型[数组长度] ; int arr[]= new int[length]
数组的静态初始化:
指定的元素的内容,系统默认长度!
静态的初始化的格式:
标准格式:
数据类型[] 数组名称 = new 数据类型[]{元素1,元素2,元素3,,,,} ;
数据类型 数组名称[] = new 数据类型[]{元素1,元素2,元素3,,,,} ;
简写方式:
数据类型[] 数组名称 = {元素1,元素2,元素3,,,,} ;
数据类型 数组名称[] = {元素1,元素2,元素3,,,,} ;
数组的遍历:
class ArrayTest3{
public static void main(String[] args){
int[] arr = {57,87,96,13,24} ;
System.out.println("逆序之前:") ;
printArray(arr) ;
//reverse(arr) ;
reverse2(arr) ;
System.out.println("逆序后:");
printArray(arr) ;
}
public static void reverse(int[] arr){
int temp = arr[0] ;
arr[0] = arr[arr.length-1-0] ;
arr[arr.length-1-0] = temp ;
temp = arr[1] ;
arr[1] = arr[arr.length-1-1] ;
arr[arr.length-1-1] = temp ;
for(int x = 0 ; x < arr.length/2; x ++){
int temp = arr[x] ;
arr[x] = arr[arr.length-1-x] ;
arr[arr.length-1-x] = temp ;
}
}
public static void printArray(int[] arr){
System.out.print("[") ;
for(int x = 0 ; x < arr.length ; x ++){
if(x==arr.length-1){
System.out.println(arr[x]+"]") ;
}else{
System.out.print(arr[x]+", ") ;
}
}
}
}
冒泡排序
冒泡排序的思想:
两两比较,将较大的值往后放,第一次比较完毕,最大值出现在
最大索引处,依次这样比较...
规律:
两两比较,将较大的值往后放
总共比较的次数:数组长度-1次
class ArrayDemo{
public static void main(String[] args){
int[] arr = {24,60,87,57,13} ;
System.out.println("排序之前:") ;
printArray(arr) ;
bubbleSort(arr) ;
System.out.println("排序之后:") ;
printArray(arr) ;
public static void bubbleSort(int[] arr){
for(int x = 0 ; x < arr.length-1 ; x ++ ){
for(int y = 0 ;y < arr.length-1-x; y++){
if(arr[y] > arr[y+1]){
int temp = arr[y] ;
arr[y] = arr[y+1] ;
arr[y+1] = temp ;
}
}
}
}
public static void printArray(int[] arr){
System.out.print("[");
for(int x = 0 ; x < arr.length ; x ++){
if(x== arr.length-1){
System.out.println(arr[x]+"]") ;
}else{
System.out.print(arr[x]+", ") ;
}
}
}
}
Day7:
二维数组的遍历
外层循环:其实是一维数组的个数(arr.length)
内层循环:其实每一个一维数组的长度(arr[x].length)
class Array2Test{
public static void main(String[] args){
int[][] arr = {{1,2,3},{4,5},{6}};
printArray2(arr) ;
}
public static void printArray2(int[][] arr){
System.out.print("{");
for(int x = 0 ; x < arr.length; x++){
System.out.print("{");
for(int y = 0 ; y < arr[x].length ; y++){
if(x == arr.length-1){
System.out.print(arr[x][y]+"}") ;
}else if(y == arr[x].length-1){
System.out.print(arr[x][y]+"}"+",") ;
}else{
System.out.print(arr[x][y]+",") ;
}
}
}
System.out.print("}");
}
}
杨辉三角形:
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
import java.util.Scanner;
class ArrayTest{
public static void main(String[] args){
Scanner sc = new Scanner(System.in) ;
System.out.println("请您输入一个数据n:") ;
int n = sc.nextInt() ;
int[][] arr = new int[n][n] ;
for(int x = 0 ; x < arr.length ; x ++){
arr[x][0] = 1 ;
arr[x][x] = 1 ;
}
for(int x = 2 ; x < arr.length ; x ++){ //行数
for(int y = 1 ; y<= x -1 ; y++){//列
arr[x][y] = arr[x-1][y-1] + arr[x-1][y] ;
}
}
for(int x = 0 ; x < arr.length ; x ++){
for(int y = 0 ; y <=x ; y++){
System.out.print(arr[x][y] +"\t") ;
}
System.out.println() ;
}
}
}
方法的形式参数分别是:基本数类型和引用类型之数组
结论:
1_形式参数如果是基本数据类型,形式参数改变对实际参数没有影响!
2_形式参数如果是引用类型(数组,类,接口),形式参数的改变对实际参数有很大影响
面向对象:
基于面向过程的一种思想!
面向过程: 代表C语言
强调一个功能的步骤
面向对象: 代表Java语言
强调对象的创建,使用对象调用功能! (用到了键盘录入Scanner类)
生活中处处都是面向对象
面向对象的思想特点:
1)更符合生活中的思想行为习惯
2)让复杂的事情简单化
3)让我们成从执行者变成了一个指挥者!
Scanner:键盘录入---->录入int类型数据/String类型数据
面向对象设计原则:
不断创建对象,使用对象,指挥该对象做事情!
面向对象的三大特征:
封装,继承,多态!
面向对象的最大特点:强调对象的创建,使用该对象调用自己的功能!
class Games{
int id ;
String sex ;
String name ;
double time ;
public void playGame(){
System.out.println("英雄联盟");
}
public void qqcom(){
System.out.println("5201314");
}
public void min(String name){
System.out.println("已玩"+name);
}
}
class StudentTest1{
public static void main(String[] args){
Games p =new Games();
System.out.println(p.id+"------"+p.sex+"--------"+p.name+"-------"+p.time);
p.id=1;
p.sex="男";
p.name="雷振毅";
p.time=40.05;
System.out.println(p.id+"------"+p.sex+"--------"+p.name+"-------"+p.time);
p.playGame();
p.qqcom();
p.min("四十分钟");
}
}
局部变量和成员变量的区别?
1)在类中的位置不同
局部变量:在方法定义中或者是方法声明上的变量
成员变量:在类中,方法外定义的变量
2)在内存中的位置不同
局部变量:在栈内存中存储 跟方法有关
成员变量:在堆内存中存储 跟类的对象有关
3)生命周期不同
局部变量:随着方法的调用而存在,随着方法的调用完毕而消失!
成员变量:随着对象的创建而存在,随着对象的创建完毕并且使用完毕,
等待垃圾回收器回收掉掉(GC)之后才消失!(不会立即被回收)
4)初始时机不同:
局部变量:在方法定义中或者方法声明上的变量,必须在使用之前进行数据初始化,否则"可能尚未初始化变量"
成员变量:跟对象有关系,在堆内存中,即使这个成员变量没有赋值,系统会根据变量的类型给这个变量进行默认初始化
形式参数如果是一个基本数据类型,形参的改变对实际参数没有影响. 需要什么类型的数据,传递具体的值即可!
形式参数如果是一个类(具体类),那么形式参数的改变直接影响实际参数!
结论:
形式参数如果传递的是一个数组类型,需要传递的该数组的对象
Day8
匿名对象:没有名字的对象
匿名对象的格式
new 类名() ; (前提条件:该类是一个具体类)
特点:
1.仅仅使用一次,使用完毕,从内存中会立即被释放掉! (节省内存空间,android移动端使用居多!)
2.匿名对象也可以作为参数进行传递
private关键字的特点:
1)private可以修饰一个类中的成员变量,也可以成员方法
2)被private修饰的成员变量或者是成员方法只能在本类中方法,外界不能访问的!(保证数据的安全性)
class Demo{
int num = 10;
private int num2 = 30 ;
public void method(){
System.out.println(num) ;
System.out.println(num2) ;
System.out.println("method demo...") ;
}
private void function(){
System.out.println("function demo...") ;
}
public void show(){
function() ;
}
}
//测试类
class PrivateDemo{
public static void main(String[] args){
Demo d = new Demo() ;
d.num = 50 ;
System.out.println(d.num) ;
System.out.println("-------------------------") ;
d.method() ;
d.show() ;
}
}
标准类:
按照上面这种方式改造---->局部变量和成员变量名称一样(局部变量隐藏了成员变量)
----为了区分成员变量和局部变量----java提供了一个关键字:this(代表了当前该类对象地址引用)
setXXX(形参)方法,谁调用这个方法,那么this代表它(地址)
this关键字:
代表引用调用当前的对象的地址值,局部变量和成员变量出现了冲突(局部变量隐藏了成员变量)
this.成员变量;
this.成员方法();
this():访问本类的无参构造.
this(""):访问本类的有参构造方法(根据参数类型)
class Student{
private String name ;
private int age;
public void setName(String name){
this.name = name ;
}
public void setAge(int age){
this.age = age ;
}
public String getName(){
return name ;
//return this.name ;
}
public int getAge(){
return age ;
}
public void study(){
System.out.println("学习Java中的面向对象...") ;
}
}
class StudentTest{
public static void main(String[] args){
Student s =new Student() ;
s.setName("正义") ;
s.setAge(22) ;
System.out.println(s.getName()+"---"+s.getAge());
s.study();
}
}
构造方法:
一个类的成员:
1)成员变量
2)成员方法
新的成员: 构造方法
什么是构造方法:
1)方法名和类名相同
2)没有具体的返回值类型
3)并且连void都没有
权限修饰符 + 方法名就是类名(){
}
构造方法主要作用:就是给该对象中的数据进行初始化!
构造方法中的注意事项:
1)在一个类中,我们不写无参构造方法,系统会默认的提供一个无参构造方法,
2)如果我们提供一个有参构造方法,系统不会在提供无参了,如果使用无参构造方法创建对象,就会报错!
(永远建议给出无参构造方法)!
成员方法的分类:(非静态的成员方法)
两种情况:
要么有返回值类型
1)有返回值类型,并且有参数
2)有返回值类型,没有参数
要么没有具体返回值:void代替
1)没有返回值类型,带参
2)没有返回值类,不带参
Day9
关于静态修饰符static的特点:
1)被static修饰的变量/方法,都随着类的加载而加载.
2)被static修饰优先于对象的存在.
3)被static修饰的,可以被多个对象共用.
使用static关键字的注意事项:
1)在static中,是没有this关键字的! (this:代表当前类的对象的地址值,对象已经创建了而static修饰的
和类有关系);
2)关于成员方法的访问问题:
非静态的成员方法
既可以访问静态的成员变量,也可以访问非静态的成员变量
既可以访问静态的成员方法,也可以访问非静态的成员方法;
静态的成员方法
简单记:静态只能访问静态