JavaSE基础（W2）总结
目录
1.Day1内容
| 方法重载 |
| 数组 |
| 数组排序之冒泡排序 |
1.方法重载
方法重载的定义（overload）：方法名相同，参数列表不同，与返回值无关。
参数列表不同：
1.参数个数不同
2.参数类型不一致
//都可以，只要参数个数、类型不同即可
public static void Test(int a , int b);
public static void Test(int a , String b);
public static void Test(String a , int b);
public static void Tset(String a ,String b);
//下面这种不可以，因为参数类型一致，就导致无法识别
public static boid Tsst(int a);
public static void Test(int b);2.数组
数组是什么：用来存储同种数据类型的容器。（类型必须一致，否则编译不能通过）
数组的定义格式：数组的索引从0开始
1数据类型[ ] 数组名称 ；如 inr [ ] arr;
2.数据类型 数组名称 [ ] ；如int arr [ ];
数组的初始化：
动态初始化：定义了数组的长度，数组的元素由系统默认初始化、
数据类型[] 数组名称 = new 数据类型[数组长度] ;
int[] arr = new int[3] ;
数据类型 数组名称[] = new 数据类型[数组长度] ;
int arr[] = new int[3]
静态数组初始化：给定了数组元素的内容，由系统指定数组长度
格式:
数据类型[] 数组名称 = new 数据类型[]{元素1,元素2,元素3...} ;(推荐)
数据类型 数组名称[] = new 数据类型[]{元素1,元素2,元素3...} ;
简写方式:
数据类型[] 数组名称 = {元素1,元素2,元素3...} ;
int[] arr = {1,2,3,4,5,6} ;
数组初始化要么是静态，要么是动态，不能静态动态并存
如：int[] arr = new int[3]{1,2,3} ;
使用数组时的注意问题：
角标越界：注意数组长度，数组长度=索引长度减1，因为数组索引从零开始计算
空指针异常：数组对象为Null时访问内部元素
例如 int [ ] arr ={ 1,2,3 } ; 这时访问( arr[ 3 ] )会出错，因为角标越界
数组的遍历：
//创建一个数组,静态初始化
int[] arr = {11,22,33,44,55} ;
System.out.print("{") ;//数组前输出一个"["
//遍历数组,获取元素内容
for(int x = 0 ; x < arr.length ; x ++){
//判断x是否能够取到最大索引值:arr.length-1
if(x==arr.length-1){
//获取最大索引值对应最后一个元素
System.out.println(arr[x]+"}") ;
}else{
//不是最后一个元素,中间的元素
//元素1, 元素2, ..
System.out.print(arr[x]+", ") ;
}
}数组排序（获取最值）
//指定一个数组,静态初始化
int[] arr = {69,45,87,13,24} ;
//定义一个参照物将arr[0]看作最大值:
int max = arr[0] ;
//遍历数组中的后面元素,1开始
for(int x = 1 ; x < arr.length ; x ++){
//判断:使用后面的元素依次和这个max进行比较
//如果后面的元素都大于max
if(arr[x]> max){
//改变max的值
max = arr[x] ;
}
}
---------------获取最小值--------------------------
//定一个参照物:它是最小值
int min = arr[0] ;
for(int x = 1; x < arr.length ; x ++){
if(arr[x] < min){
min = arr[x] ;
}
}
数组的元素逆序：
//创建数组,并静态初始化
int[] arr = {14,69,24,78,52} ;
public static void reverse(int[] arr){
for(int x = 0 ; x < arr.length/2; x ++){//数组长度/2保证不会进行多余互换
//采用中间变量方式互换
int temp = arr[x] ;
arr[x] = arr[arr.length-1-x] ;//将arr[0]和arr.length-1进行互换，...一次类推
arr[arr.length-1-x] = temp ;
}
}
-------------方式2--------------
//方式2
public static void reverse2(int[] arr){
//start,end:索引值。将start视为数组索引开头，将end是为数组的末尾，进行互换
for(int start = 0 ,end = arr.length-1 ; start < end ;start ++,end -- ){
//使用中间变量的方式
int temp = arr[start] ;
arr[start] = arr[end] ;
arr[end] = temp ;
}
}
元素查表法：
//已知字符串数组
String[] strs = {"星期一","星期二","星期三","星期四","星期五","星期六","星期日"} ;
//创建键盘录入对象
Scanner sc = new Scanner(System.in) ;
//提示并录入
System.out.println("请输入一个数据(0-6):") ;
int num = sc.nextInt() ;
System.out.println("当前是"+strs[num]) ;数组中基本元素查找：基本查询，在数组中从头查到末尾
//已知一个数组,静态初始化
int[] arr = {69,78,34,200,120} ;
//查询34这个元素第一次在数组中出现索引值
int index = getIndex(arr,34) ;
int index = getIndex2(arr,120) ;//查询120，查询成功显示角标，查询不到显示-1
System.out.println("index:"+index) ;
public static int getIndex(int[] arr,int target){
for(int x = 0 ; x < arr.length ; x ++){//遍历数组
//获取到元素
//判断:如果当前要查询的target元素和arr[x]元素一致
if(target == arr[x]){
return x ; //找到了返回”x“值
}
}
//找不到返回-1
return -1 ;
}
----------方式2------------
public static int getIndex2(int[] arr,int key){
//定义一个变量index
int index = -1 ; //假设找不到最后返回值为-1
//遍历arr数组
for(int x = 0 ; x < arr.length ; x ++){
//判断
if(arr[x] == key){
index = x ;
break ;
}
}
return index ;
}
3.数组的冒泡排序：
两两比较,将较大的值往后方法,第一次比较完毕,最大值出现在最大索引处!依次这样比较...
最终比较次数:数组长度-1次
//创建一个数组,静态初始化
int[] arr = {24,69,87,56,13} ;
public static void bubbleSort(int[] arr){
for(int x = 0 ; x < arr.length-1 ; x ++){ //比较数组长度-1次
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]+"]") ;//数组末尾输出]
}
}
}
Day2内容
| 键盘录入 |
| 形参传递--作为参数传递 |
| 面向对象 |
| 局部变量和成员变量的区别 |
| 引用类型作为参数传递--类 |
| 匿名对象 |
1.键盘录入：
键盘录入有三种方式
1)早期的 main(String[] args)
String[]:字符串数组
args:形式参数名
弊端:只能接收字符串
2)方式2:JD5以后使用的:Scanner:文本扫描器
导包:import java.util.Scanner;
3)第三种方式:利用的BufferedReader:字符缓冲输入流 (IO流部分)
功能:readLine() :读取一行内容
java.io.BufferedReader;
2.形参的传递---作为参数传递
方法的形式参数传递:
1)基本数据类型作为参数传递:四类八种
形式参数的改变不影响实际参数!
//定义两个变量a,b
int a = 10 ;
int b = 20 ;
System.out.println("a:"+a+",b:"+b) ;//10,20
change(a,b) ;//调用change值发生改变，输出为20，40
System.out.println("a:"+a+",b:"+b) ;//基本数据类型参数传递不改变实际值，所以数据还是10,20
public static void change(int a,int b){
System.out.println("a:"+a+",b:"+b) ;//10,20
a = b ; // a = 20
b = a + b ; // b = 20 + 20 = 40
System.out.println("a:"+a+",b:"+b) ;//20,40
}
2)引用类型作为参数传递:数组,类,接口
形式参数改变会直接影响实际参数(String除外,它作为参数传递和基本类型作为参数传递效果一致!)
//引用数据类型作为参数传递：
//定义两个变量a,b
int a = 10 ;
int b = 20 ;
//创建一个数组,静态初始化
int[] arr = {1,2,3,4,5} ;
System.out.println(arr[3]) ; //此时sarr数组角标3的值为4
change(arr) ;
System.out.println(arr[3]) ; //经过重载change方法角标3的值*2，得到8
//重载的change方法
public static void change(int[] arr){
//遍历数组
for(int x = 0 ; x < arr.length ; x ++){
if(arr[x] % 2 ==0){ //此时2；4都符合条件
arr[x] *= 2 ;
}
}
}
3.面向对象：
1)让复杂的事情简单化
2)让我们从执行者变成了指挥者(角色发生了变化)
3)更符合我们生活中的思想行为习惯...
面向对象的设计原则 : 在不断的创建对象,使用对象,指挥对象做事情
使用： 创建对象
类名 对象名 = new 类名();
对象名.成员变量= 赋值
对象名.成员方法() ; 使用这个方法
成员变量(在类中,方法外定义):name,age,stuId,gender,hight...
成员方法:(去掉static关键字): 之前的方法怎么定义,现在还怎么定义,只是去掉static即可!
//定义手机类
class Phone{
//成员变量
String brand ; //品牌
int price ; //价格
String phoneColor ; //手机颜色
String phoneDesc ;//手机描述信息
//成员方法
public String callPhone(String name){
return "给"+name+"可以打电话" ;
}
public void sendMsg(){
System.out.println("手机可以发短信...") ;
}
//手机类的测试类
class PhoneTest{
public static void main(String[] args){
//创建Phone类对象
//类名 对象名 = new 类名() ;
Phone p = new Phone() ;
System.out.println(p) ;//此时的”p“还未进行录入数据，所以输出一个地址值
System.out.println(p.brand+"---"+p.price+"---"+p.phoneColor+"---"+p.phoneDesc) ;//输出默认值Null---0----Null----Null;
System.out.println("-------------------------------") ;
//给成员变量赋值
p.brand = "三星" ;
p.price = 1999;
p.phoneColor = "黑" ;
p.phoneDesc = "我就是Android机皇" ;
System.out.println(p.brand+"---"+p.price+"---"+p.phoneColor+"---"+p.phoneDesc) ;
//调用方法
String s = p.callPhone("张三") ;
System.out.println(s) ;
p.sendMsg() ;还可以创建多个手机类：
class Phone{
//成员变量
String brand ;
int price ;
String color ;
//成员方法
public String callPhone(String name){
return "给"+name+"可以打电话" ;
}
public void sendMsg(){
System.out.println("手机可以发短信...") ;
}
public void playGame(){
System.out.println("手机可以玩游戏...") ;
}
//定义一个成员方法:目的 方便调用直接输出
public void show(){
System.out.println(brand+"---"+price+"---"+color) ;
}
}
class PhoneTest2{
public static void main(String[] args){
//创建第一个手机类对象
Phone p1 = new Phone() ;
p1.brand = "三星note10" ;
p1.price = 6999;
p1.color = "黑" ;
System.out.println(p1.brand+"---"+p1.price+"---"+p1.color) ;
String s = p1.callPhone("张三") ;
System.out.println(s) ;
p1.sendMsg() ;
p1.playGame() ;
System.out.println("--------------------------------------") ;
Phone p2 = new Phone() ;
p2.brand = "三星galaxy20" ;
p2.price = 7999 ;
p2.color = "白" ;
p2.show() ;
String s2 = p2.callPhone("李四") ;
System.out.println(s2) ;
p2.sendMsg() ;
p2.playGame() ;
System.out.println("--------------------------------------") ;
//将p1赋值p3对象
Phone p3 = p1 ;
//Phone p3 = new Phone();
p3.brand = "三星note20" ;
p3.price = 9999 ;
p3.color = "蓝" ;
System.out.println(p1.brand+"---"+p1.price+"---"+p1.color) ;
}
}
4.局部变量和成员变量的区别
| 区别 | 局部变量 | 成员变量 |
| 代码书写位置 | 在方法中定义 或在方法声名上的的变量 | 在类中方法外 |
| 内存中位置 | 在栈内存 | 在堆内存 |
| 生命周期 | 随着对象创建而存在， 随着对象创建完毕，等待垃圾回收器回收 (对象创建完毕,对象可能被继续使用,所以不会立即消失!) | 随着方法调用而存在， 随着方法调用结束儿消失 （使用完毕立即消失） |
| 初始化不同 | 定义的时候，使用前必须初始化，要么直接初始化，不能没有初始化值 | 随着类的加载而存在， 存在系统默认初始化， 可以不直接赋值，但也可以赋值 |
5.引用类型作为实参传递
//定义一个学生类
class Student{
//定义一个成员方法
public void study(){
System.out.println("Good Good Study ,Day Day Up!!!") ;
}
}
//定义一个类StudentDemo类
class StudentDemo{
//有一个成员方法:method
public void method(Student s){//形式参数是Student类型
s.study() ; // 形式参数变量s.study():s应该在传递----学生类的对象!
}
}
//测试类
class StudentTest{
public static void main(String[] args){
//创建StudentDemo类的对象
StudentDemo sd = new StudentDemo() ;
//method方法中的参数传递:实际参数需要的是Student的具体对象
Student s = new Student();
sd.method(s) ;
}
}6.匿名对象
匿名对象: 顾名思义就是没有名字的对象!
格式:
new 类名() ;
特点:
1)开发中使用一次即可
2)使用完毕,立即被回收,可以结束内存空间!
这种写法针对:移动端: Android(考虑内存问题)
3)作为参数传递
pc端:推荐:
类名 对象名 = new 类名() ;
class Student{
//成员方法
public void study(){
System.out.println("爱生活,爱Java...") ;
}
}
class StudentDemo{
public void method(Student s){
s.study() ;
}
}
//测试类中
class NoNameDemo{
public static void main(String[] args){
//访问StudentDemo类中method
//创建StudentDemo类的对象
StudentDemo sd = new StudentDemo() ;
//创建一个具体的学生类对象
Student s= new Student() ;
sd.method(s) ;
//匿名对象
new StudentDemo().method(new Student()) ;
}
}
Day3内容
| 封装 |
| this关键字 |
| 构造方法 |
1.封装
封装:
将一个事物的属性,私有化(对外进行隐藏),外界不能直接访问(保证了数据安全性),需要提供对外的公共访问来访问成员变量!
private:
私有的,外界无法访问的,只能在本类中访问
private关键字的特点:
被private修饰的成员变量/成员方法,都只能在本类中访问;
外界类不能直接访问,但是可以通过公共方法间接访问
class Code{
//成员变量
int num = 20 ;
//私有成员变量
private int num2 = 30 ;
//定义一个method方法:公共的
public void method(){
System.out.println(num) ;
System.out.println(num2) ;
}
//私有的成员方法
private void function(){
System.out.println("function code...") ;
}
public void show(){
System.out.println("show code...");
function() ;
}
}
class privateDemo{
public static void main(String[] args){
//要访问Code类中num和num2
Code code = new Code() ;
System.out.println(code.num) ;
code.method() ;
System.out.println("--------------") ;
code.show() ;
}
}2.this关键字：
局部变量和成员变量都叫name,如何区分呢? 这个时候Java提供了一个关键字:this
局部变量隐藏了成员变量,使用this关键字来区分
public void setName(String name) ;
this. name = name ;
}
this:代表了当前类的对象的地址值的引用!
//使用setXXX；getxxx方法
//public void setName(String n){
public void setName(String name){
//name = n ;
//name = name ;
this.name = name ; //区分了成员变量和局部变量
}
/*
public void setAge(int a){
age = a ;
}
*/
public void setAge(int age){
//age = age ;
this.age = age ;
}
//getXXX()
public String getName(){
return name ;
}
public int getAge(){
return age ;
}
class StudentTest{
public static void main(String[] args){
Student s = new Student() ;
s.setName("高圆圆") ;
s.setAge(30) ;
}
}
3.构造方法：
什么是构造方法：构造方法是一个方法,特殊的方法
1)方法名和类名一致!
2)没有具体返回值类型
3)连void都没有
格式:
权限修饰符(public:目前使用居多) + 类名(xx){}
public Teacher(){
System.out.println("这是个无参构造方法...");
}
| 构造方法的分类: | 无参构造方法 |
| 有参构造方法 | |
| 构造方法作用: | 就是为了 给类中的成员变量进行数据的初始化!(构造方法初始化!) 构造方法是可以重载的; |
注意事项:
当前我们定义一个类的时候,没有提供任何构造方法,那么系统会默认无参构造方法;
但是,如果我们提供一个有参构造方法,系统不会在提供无参构造方法!(建议永远给出无参构造方法)
一个类的组成:
1)成员变量
2)加入构造方法
无参
有参构造方法
3)成员方法
class Student{
//属性私有化
private String name ; //姓名
private int age ; //年龄
//无参构造方法(永远给出)
public Student(){
}
//有参构造方法
public Student(String name,int age){//"张三",19
this.name = name ;
this.age = age ;
}
//提供成员方法
//setXXX()getXXX()
public void setName(String name){
this.name = name ;
}
public String getName(){
return name ; //隐藏 : return this.name ; 将this省略了
}
public void setAge(int age){
this.age = age ;
}
public int getAge(){
return age ;
}
//提供其他成员方法
public String study(String className){
return "学习"+className;
}
public void playGame(){
System.out.println("玩游戏...") ;
}
}
//测试类
class Test{
public static void main(String[] args){
//方式1:无参构造方法+setXXX() +getXXX()
Student s = new Student() ;
s.setName("张三") ;
s.setAge(19) ;
System.out.println("姓名是"+s.getName()+",年龄是:"+s.getAge()) ;
String result = s.study("Java") ;
System.out.println(result) ;
s.playGame() ;
System.out.println("----------------------------------") ;
//方式2:有参构造方法+getXXX()
Student s2 = new Student("李四",20) ;
System.out.println("姓名是"+s2.getName()+",年龄是:"+s2.getAge()) ;
String result2 = s2.study("Python") ;
System.out.println(result2) ;
s2.playGame() ;
}
}
扫一扫
2465
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
