初学Java总结

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)关于成员方法的访问问题:
                非静态的成员方法
                    既可以访问静态的成员变量,也可以访问非静态的成员变量
                    既可以访问静态的成员方法,也可以访问非静态的成员方法;
                
                静态的成员方法
                    简单记:静态只能访问静态