JavaSE基础知识
一.方法(函数)
先看一段代码:
public static void main(String[] args) {
//请计算 10 和 20 的和
int a = 10;
int b = 20;
int c = a + b;
System.out.println(a + "+" + b + "=" + c);
//请计算 666 和 888 的和
int x = 666;
int y = 888;
int z = x + y;
System.out.println(x + "+" + y + "=" + z);
//请计算 888 和 999 的和
int m = 888;
int n = 999;
int e = m + n;
System.out.println(m + "+" + n + "=" + e);
}
计算两个数或者三个数甚至更多的数字,用的方法都是一样的,给变量赋值之后进行加
法计算.数字少很好解决,但是如果是多组数字一直加,就会造成代码的冗余度过高,虽
然代码的难度不是很高,但是会导致代码的冗余度(重复度)过高!这不是一段好的代码
1.1方法的概念
引入方法:
public static void main(String[] args) {
//调用求和方法计算 10 和 20 的和
sumInt(10 , 20);
//调用求和方法计算 666 和 888 的和
sumInt(666 , 888);
//调用求和方法计算 888 和 999 的和
sumInt(888 , 999);
}
//专门负责求和的方法
public static void sumInt(int a , int b){
int c = a + b;
System.out.println(a + "+" + b + "=" + c);
}
方法就是在代码中能解决业务的一段代码块,而且可以被重复调用.在Java中,被叫做
方法,在C语言中被叫做函数.
1.2 方法的定义以及调用
1.2.1 方法的定义
//[修饰符列表] 返回值类型 方法名(形式参数列表){方法体;}
//例如代码：
public static void sumInt(int a , int b){
int c = a + b;
System.out.println(a + "+" + b + "=" + c);
}
//public static 是修饰符列表；
//void 是返回值类型；
//sumInt 是方法名；
//(int a , int b)是形式参数列表，简称形参，每一个形参都是局部变量；形参
//后面使用一对儿大括号括起来的是方法体，方法体是完成功能的核心代码.方法体
//内是Java代码,遵守Java代码的执行规则,自上而下执行,直至末尾.
1.2.2 方法的调用
调用方法的语法格式（前提是方法的修饰符列表中带有 static 关键字）：
“类名.方法名(实际参数列表);”，
例如:
public class MethodTest {
public static void main(String[] args) {
MethodTest.sumInt(100, 200);
MethodTest.sumDouble(1.0, 2.0);
}
//调用方法
public static void sumInt(int x , int y){
System.out.println(x + "+" + y + "=" + (x + y));
}
public static void sumDouble(double a , double b){
System.out.println(a + "+" + b + "=" + (a + b));
} }
执行结果:
100+100=200
1.0+2.1=3.0
1.2.3方法返回值详解
java 语言中方法的返回值类型可以是任何一种数据类型，包括基本数据类型，也包
括引用数据类型，例如：byte,short,int,long,float,double,boolean,char
,String,Student（自定义类）等。当然，如果这个方法在执行完之后不需要返回任
何数据，返回值类型必须写void 关键字，不能空着不写。
代码中返回值的常见错误:
//错误1:缺少返回语句
public static int getMax(int a,int b){
}
/*如果这样写的话就是缺少返回语句,因为方法定义中会返回int类型的数据,没有返
回语句编译会报错,缺少返回语句*/
//错误2:
public static int method1(){
return 1;
System.out.println("hello world!");
}
/*编译时会提醒:最后一句输出语句是无法访问到的语句.
在方法中,一旦遇到"return"语句,方法就会结束,所以最后一行输出语句就无法执
行到*/
//错误3:
public static int method1(){
boolean flag = true;
if(flag){
return 1;
}
}
//如果方法中有逻辑判断,就要保证一定要能执行到,不然会报错没有返回语句
1.2.4方法重载
这是求和的一段代码:
public static void main(String[] args) {
int x1 = 10;
int x2 = 20;
int retValue1 = sumInt(x1 , x2);
System.out.println(x1 + "+" + x2 + "=" + retValue1);
long y1 = 10L;
long y2 = 20L;
long retValue2 = sumLong(y1 , y2);
System.out.println(y1 + "+" + y2 + "=" + retValue2);
double z1 = 10.0;
double z2 = 20.0;
double retValue3 = sumDouble(z1, z2);
System.out.println(z1 + "+" + z2 + "=" + retValue3);
}
public static int sumInt(int a , int b){
return a + b;
}
public static long sumLong(long a , long b){
return a + b;
}
public static double sumDouble(double a , double b){
return a + b;
}
这一段代码的三个方法求相似,功能是一样的,都是用来求和的方法,但是却
定义了三个方法,只是数组不一样,数据类型不一样,这样的代码冗余度也很
高,而且数字越多越麻烦,看起来也不是很美观.
在同一个类当中，如果多个功能是相似的，可以将它们的方法名定义的一致，使用
方法重载机制，如果两个方法所完成的功能完全不同，那么方法名也一定要不一样，
这样才是合理的。
代码满足什么条件的时候构成方法重载!
① 在同一个类当中。
② 方法名相同。
③ 参数列表不同：个数不同算不同，顺序不同算不同，类型不同也算不同。
public class U {
public static void p(){
System.out.println();
}
public static void p(int data){
System.out.println(data);
}
public static void p(long data){
System.out.println(data);
}
public static void p(float data){
System.out.println(data);
}
public static void p(double data){
System.out.println(data);
}
public static void p(boolean data){
System.out.println(data);
}
public static void p(char data){
System.out.println(data);
}
public static void p(String data){
System.out.println(data);
}}
public class UTest {
public static void main(String[] args) {
U.p("hello world!");
U.p(10);
U.p(9.0);
U.p(false);
U.p('国');
int a = 10;
int b = 20;
int c = a + b;
U.p(a + "+" + b + "=" + c);
}
}
运行结果:
2.2数组的声明
方法一:
数据类型 [] 数组名称 = new 数据类型[数组长度];
这里 [] 可以放在数组名称的前面，也可以放在数组名称的后面,但是推荐放在前面
方式二:
数据类型 [] 数组名称 = {数组元素1,数组元素2,数组元素3};
这种方式给定了数组中的元素,数组的大小由给定的元素的个数决定.
访问数组中的元素:
数组中的每一个元素都有对应的编号,也就是下标,数组中的下标走0开始,0队友数组
中的第一个元素,下标1对应数组中的第二个元素,以此类推.
//声明数组,声明一个长度为3，只能存放int类型的数据
int [] myArray = new int[3];
//给myArray第一个元素赋值1
myArray[0] = 1;
//访问myArray的第一个元素
System.out.println(myArray[0]);
数组遍历:,数组还有一个属性,叫做数组的长度,length,用arr.length可以表示数
组的长度,可以用数组的长度来遍历数组
//声明数组2,声明一个数组元素为 1,2,3的int类型数组
int [] myArray2 = {1,2,3};
for(int i = 0 ; i < myArray2.length ; i++)
{System.out.println(myArray2[i]); }
2.3数组与方法的应用—冒泡排序
1.冒泡排序是数据结构中的排序方法.也是最稳定的排序方法之一.
2.思想:从数组中的第一个数字开始依次和数组中其他的元素进行比较,讲数组中最大
的元素放在末尾,然后循环到数组中左右的元素按从小到大的顺序排列.
//代码实现:
//建立数组:
int [] arr = {62,13,56,95,22,66};
System.out.println("排序之前:");
printArray(arr);//遍历数组
System.out.println("--------------------------------------");
System.out.println("排序之后:");
bubbleSort(arr);//进行排序
printArray(arr);//进行排序后的遍历
}
//遍历数组的方法:
public static void printArray(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 bubbleSort(int [] arr){
//排序的次数
for(int k = 0;k < arr.length-1;k++){
for(int j = 0;j < arr.length-1-k;j++){
//每一次进行排序之后,就会减少一个需要对比的数字
if(arr[j] > arr[j+1]){
int temp =arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
}
}
二.面向对象(Java中的核心内容)
2.1面向对象与面向过程的区别
面向过程:
“面向过程”(Procedure Oriented)是一种以过程为中心的编程思想，简称 OP。
“面向过程”也可称之为“面向记录”编程思想，就是分析出解决问题所需要的步骤，
然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了。
以面向过程的编程方式关注点不在“事物”上，而是做这件事分几步，先做什么，
后做什么
面向对象:
“面向对象”(Object Oriented)是一种以对象为中心的编程思想，简称 OO。
一切事物皆对象，通过面向对象的方式，将现实世界的事物抽象成对象。通过面
向对象的方法，更利于用人理解的方式对复杂系统进行分析、设计与编程。
举例:
假如说编写一段程序，模拟一个人抽烟的场景，采用面向过程的方式是这样的：
买烟->买打火机->找能够抽烟的场合->点燃香烟->开抽，只要按照这个流程一步一
步来，就可以实现抽烟场景
采用面向对象的方式关注点就不一样了，我们会想这个场景都有什么事物参与
，每个事物应该有什么行为，然后将这些事物组合在一起，来描述这个场景，
例如：一个会抽烟的人（对象）+香烟（对象）+打火机（对象）+允许抽烟的
场所（对象），将以上 4 个对象组合在一起，就实现了抽烟场景，
2.2.面向对象的三大特征:
①封装
②继承
③多态(重点 重点 重点) 任何一门面向的的语言都会具备这些特征
2.3.类与对象
类是现实世界当中具有共同特征的事物进行抽象形成的模板或概念。而对象是实际
存在的个体。例如：“汽车”就是一个类（所有的汽车都有方向盘、发动机、都能形式
，这是它们的共同特征），而奔驰,宝马,具体的汽车就是对象,都是实际存在的个体
类可以创建对象，对象又被称为实例（instance），这个过程也可以称为实例化,
走对象到类的过程称为抽象..
类 = 属性 + 方法，而属性描述的是状态，方法描述的是行为动作。
2.3.1类的定义
定义类的格式:
[修饰符] class 类名 {
类体 = 属性 + 方法
}
例如书写一个学生类:
//学号,姓名,年龄.性别都是类的属性,必须要创建对象才能访问,
public class Student {
//学号
int no;
//姓名
String name;
//年龄
int age;
//性别
boolean sex;
}
2.4.对象的创建和使用
创建的方法:new 类名()，这样就可以完成对象的创建了。
俗话说，你想要什么 java 都可以给你，想要啥你就 new啥。
示例:
public class StudentTest {
public static void main(String[] args) {
//创建一个学生对象
Student s1 = new Student();
//再创建一个学生对象
Student s2 = new Student();
}
}
对象的使用:创建了对象之后就可以去访问类中的属性了.
public class StudentTest {
public static void main(String[] args) {
//创建一个学生对象
Student s1 = new Student();
//再创建一个学生对象
Student s2 = new Student();
//以上代码其实和这行代码差不多
int i = 10;
int no1 = s1.no;
System.out.println("学号：" + no1);
String name1 = s1.name;
System.out.println("姓名：" + name1);
int age1 = s1.age;
System.out.println("年龄：" + age1);
boolean sex1 = s1.sex;
System.out.println("性别："+ sex1);
int no2 = s2.no;
System.out.println("学号：" + no2);
String name2 = s2.name;
System.out.println("姓名：" + name2);
int age2 = s2.age;
System.out.println("年龄：" + age2);
boolean sex2 = s2.sex;
System.out.println("性别：" + sex2);
}
}
2.5Java虚拟机(JVM)的内存管理
Java代码执行需要JVM的参与,JVM中有不同的存储位置:
栈内存:存储局部变量(在方法内或者方面命名上)
堆内存:new出来的东西(创建的对象)
方法区内存:class文件(字节码文件)
内存图解:
解释:字节码文件和方法存放在方法区内存中,main方法是程序的开头,走main方法
开始向下执行,main方法在栈内存中开辟空间地址,定义的数组在栈内存中开辟地址,
新创建的数组在堆内存中开辟空间地址,并且对数组进行默认舒适化,每个类型系统
进行默认舒适化都有一个默认的值,然后产生了一个内存空间地址值,对应的是栈内存
中间的空间地址值,
2.6this关键字的使用
在实际开发中,为了起名字(变量/方法/类)见名知意,然后就引入了this关键字.
局部变量名称和成员变量名称一致(局部变量隐藏了成员变量),Java提供了一个关键字:this:代表当前类对象的地址值引用
举例:
/*2.创建一个Address 类，描述如下：
(属性私有化,提供对外公共访问方法:封装改进)
该类有两个属性，
1)String 类型的address，表示地址；2)String 类型
的zipCode，表示邮编。
2)定义成员方法：show方法，显示 address和邮信息
例如:
地址是: xxx
邮编是：xxx
*/
//创建一个Adress的类
class Address
{ //定义属性
private String address;
private int zipCode;
//定义get set方法
//地址(address的)
public void setAddress(String address){
this.address = address;
}
public String getAddress(){
return address;
}
//邮编的zipcode
public void setZipCode(int zipCode){
this.zipCode = zipCode;
}
public int getZipCode(){
return zipCode;
}
//定义方法
//show方法可以显示地址和邮编
public void show(){
System.out.println(address);
System.out.println(zipCode);
}
}
class AddressTest
{ public static void main(String[] args){
Address B = new Address();
B.setAddress("陕西省西安市雁塔区");
B.setZipCode(724400);
B.show();
}
}
3.封装及标准类的写法
什么是封装?
将一个真实事物(类)的属性私有化,保证安全性,外界不能访问,然后提供公共的访问
方法,间接访问.以对外提供的访问入口应该有两个，这两个方法通常被称为 set 方
法和 get 方法
封装的好处:
使用 java 语言中的 private 修饰符，private 修饰的数据表示私有的，私有的
数据只能在本类当中访问,
举例:
//1.手机有品牌(brand),价格,颜色,内存等属性,手机可以打电话,发短信,打游戏等行为,
//请使用面向对象的方式描述手机并且进行测试(加入封装)
//定义一个手机类
class Phone
{ //手机的属性
private String brand;//品牌
private int price; //价格
private String color;//颜色
private int memory; //内存
//setXXX()和getXXX()的方法
//品牌
public void setBrand(String brand){
this.brand = brand;
}
public String getBrand(){
return brand;
}
//价格
public void setPrice(int price){
this.price = price;
}
public int getPrice(){
return price;
}
//颜色
public void setColor(String color){
this.color = color;
}
public String getColor(){
return color;
}
//内存
public void setMemory(int memory){
this.memory = memory;
}
public int getMemory(){
return memory;
}
//手机的其他方法
//打电话
public void callOther(String name){
System.out.println("你可以打电话给"+name);
}
//发短信
public void sendMes(String name1){
System.out.println("你可以发短信给"+name1);
}
//玩游戏
public void playGame(){
System.out.println("你可以玩任何游戏");
}
}
class PhoneTest
{ public static void main(String[] args){
//创建一个手机的对象,才能访问手机类
Phone H = new Phone();
//通过set()方法对手机的属性赋值
H.setBrand("小米10");
H.setPrice(2999);
H.setColor("黑色");
H.setMemory(256);
//输出
//通过get()方法可以获取到给类中的属性赋的值
System.out.println("这个手机的品牌为:"+H.getBrand()+"价格为:"+H.getPrice()+"颜色为:"+H.getColor()+"内存为:"+H.getMemory());
H.callOther("张三");
H.sendMes("李四");
H.playGame();
}
}