目录
类
基础使用
1.什么是类
类是一类具有相同特性的事物的抽象描述，是一组相关属性和行为的集合。
-
属性：就是该事物的状态信息。
-
行为：就是在你这个程序中，该状态信息要做什么操作，或者基于事物的状态能做什么。
2.如何定义类
格式：
【修饰符】 class 类名{
}
成员变量
1.如何声明成员变量
【修饰符】 class 类名{
【修饰符】 数据类型 成员变量名;
}public class Person{ String name; char gender; int age; }位置要求：必须在类中，方法外
类型要求：可以是Java的任意类型，包括基本数据类型、引用数据类型（类、接口、数组等）
修饰符：成员变量的修饰符有很多，例如：public、protected、private、static、volatile、transient、final等，后面会学习。
2、实例变量的访问
格式：
对象.实例变量
package com.atguigu.test03.field; public class TestPerson { public static void main(String[] args) { Person p1 = new Person(); p1.name = "张三"; p1.age = 23; p1.gender = '男'; Person p2 = new Person(); /* （1）实例变量的值是属于某个对象的 - 必须通过对象才能访问实例变量 - 每个对象的实例变量的值是独立的 （2）实例变量有默认值 */ System.out.println("p1对象的实例变量："); System.out.println("p1.name = " + p1.name); System.out.println("p1.age = " + p1.age); System.out.println("p1.gender = " + p1.gender); System.out.println("p2对象的实例变量："); System.out.println("p2.name = " + p2.name); System.out.println("p2.age = " + p2.age); System.out.println("p2.gender = " + p2.gender); }
对象
1.什么是对象
对象是一类事物的一个具体个体（对象并不是找个女朋友）。即对象是类的一个实例，必然具备该类事物的属性和行为。
例如：做一个养宠物的小游戏
类：人、猫、狗等
2.对象的创建
new 类名( )//也称为匿名对象
//给创建的对象命名
//或者说，把创建的对象用一个引用数据类型的变量保存起来，这样就可以反复使用这个对象了
类名 对象名 = new 类名();
那么，对象名中存储的是什么呢？答：对象地址
public class TestStudent{
public static void main(String[] args){
System.out.println(new Student());//Student@7852e922
Student stu = new Student();
System.out.println(stu);//Student@4e25154f
int[] arr = new int[5];
System.out.println(arr);//[I@70dea4e
}
}发现学生对象和数组对象类似，直接打印对象名和数组名都是显示“类型@对象的hashCode值"，所以说类、数组都是引用数据类型，引用数据类型的变量中存储的是对象的地址，或者说指向堆中对象的首地址。
(这里关于内存的内容先不要着急了解，我们后面会慢慢讲到的)
方法
基本知识
方法也叫函数，是一组代码语句的封装，从而实现代码重用，从而减少冗余代码，通常它是一个独立功能的定义，方法是一个类中最基本的功能单元。
1.方法的特点
（1）必须先声明后使用
（2）不调用不执行，调用一次执行一次。
2、声明方法的语法格式
【修饰符】 返回值类型 方法名(【形参列表 】)【throws 异常列表】{
方法体的功能代码
}
3.声明方法的位置
类{
方法1(){
}
方法2(){
}
}
4.如何调用实例方法
语法格式:
对象.非静态方法(【实参列表】)
package com.atguigu.test04.method; /** * 方法调用案例演示 */ public class MethodInvokeDemo { public static void main(String[] args) { //创建对象 MethodDefineDemo md = new MethodDefineDemo(); System.out.println("-----------------------方法调用演示-------------------------"); //调用MethodDefineDemo类中无参无返回值的方法sayHello md.sayHello(); md.sayHello(); md.sayHello(); //调用一次，执行一次，不调用不执行 System.out.println("------------------------------------------------"); //调用MethodDefineDemo类中有参无返回值的方法printRectangle md.printRectangle(5,10,'@'); System.out.println("------------------------------------------------"); //调用MethodDefineDemo类中无参有返回值的方法getIntBetweenOneToHundred md.getIntBetweenOneToHundred();//语法没问题，就是结果丢失 int num = md.getIntBetweenOneToHundred(); System.out.println("num = " + num); System.out.println(md.getIntBetweenOneToHundred()); //上面的代码调用了getIntBetweenOneToHundred三次，这个方法执行了三次 System.out.println("------------------------------------------------"); //调用MethodDefineDemo类中有参有返回值的方法max md.max(3,6);//语法没问题，就是结果丢失 int bigger = md.max(5,6); System.out.println("bigger = " + bigger); System.out.println("8,3中较大者是：" + md.max(8,9)); } }
5.形参和实参
-
形参（formal parameter）：在定义方法时方法名后面括号中声明的变量称为形式参数（简称形参）即形参出现在方法定义时。
-
实参（actual parameter）：调用方法时方法名后面括号中的使用的值/变量/表达式称为实际参数（简称实参）即实参出现在方法调用时。
-
调用时，实参的个数、类型、顺序顺序要与形参列表一一对应。如果方法没有形参，就不需要也不能传实参。
-
无论是否有参数，声明方法和调用方法是都不能丢失
6.实例方法使用当前对象的成员(this.)
详解this.
this可以用来修饰、调用：属性、方法、构造器
1.调用属性
private String name; private int age; public void setName(String name){ this.name = name; }2.调用方法
调用上一级的方法
public void eat(){ System.out.println("人吃饭"); this.study(); } public void study(){ System.out.println("人学习"); }调用eat（）方法
p1.eat();运行结果为：
3.调用构造器
1.可以采用 this() / this(age) 来进行调用之前的构造器，同时这个语句必须放在第一行。且不可以反复调用，以免形成圆圈调用。
2.我们在类的构造器中，可以显式的使用"this(形参列表)"方式，调用本类中指定的其他构造器
3.构造器中不能通过"this(形参列表)"方式调用自己
4.如果一个类中有n个构造器，则最多有 n - 1构造器中使用了"this(形参列表)"
5.规定："this(形参列表)"必须声明在当前构造器的首行6.构造器内部，最多只能声明一个"this(形参列表)"，用来调用其他的构造器
public class ThisTest { private String name; private int age; public ThisTest(){ System.out.println("无参构造器"); }; public ThisTest(String name){ this(); System.out.println("有一个参数的构造器"); this.name = name; } public ThisTest(String name, int age){ this("name"); System.out.println("有两个参数的构造器"); this.age = age; } public static void main(String[] args) { ThisTest thisTest = new ThisTest("Mr.Yu",21); } }运行结果：
参数问题
1.1特殊参数之一：可变参数
两种写法：
1.【修饰符】 返回值类型 方法名(【非可变参数部分的形参列表,】参数类型... 形参名){ }
2.【修饰符】 返回值类型 方法名(【非可变参数部分的形参列表,】参数类型[] 形参名){ }
（1）一个方法最多只能有一个可变参数
（2）如果一个方法包含可变参数，那么可变参数必须是形参列表的最后一个
（3）在声明它的方法中，可变参数当成数组使用
后面这种定义，在调用时必须传递数组，而前者更灵活，既可以传递数组，又可以直接传递数组的元素，这样更灵活了。
public class NumberTools {
int total(int[] nums){
int he = 0;
for (int i = 0; i < nums.length; i++) {
he += nums[i];
}
return he;
}
int sum(int... nums){
int he = 0;
for (int i = 0; i < nums.length; i++) {
he += nums[i];
}
return he;
}
}public class TestVarParam {
public static void main(String[] args) {
NumberTools tools = new NumberTools();
System.out.println(tools.sum());//0个实参
System.out.println(tools.sum(5));//1个实参
System.out.println(tools.sum(5,6,2,4));//4个实参
System.out.println(tools.sum(new int[]{5,6,2,4}));//传入数组实参
System.out.println("------------------------------------");
System.out.println(tools.total(new int[]{}));//0个元素的数组
System.out.println(tools.total(new int[]{5}));//1个元素的数组
System.out.println(tools.total(new int[]{5,6,2,4}));//传入数组实参
}
}1.2方法包含非可变参数和可变参数
1. 非可变参数部分必须传入对应类型和个数的实参；
2.可变参数部分按照可变参数的规则传入0~n个对应类型的实参或传入1个对应类型的数组实参；
案例：
n个字符串进行拼接，每一个字符串之间使用某字符进行分割，如果没有传入字符串，那么返回空字符串" "
public class StringTools { String concat(char seperator, String... args){ String str = ""; for (int i = 0; i < args.length; i++) { if(i==0){ str += args[i]; }else{ str += seperator + args[i]; } } return str; } }public class StringToolsTest { public static void main(String[] args) { StringTools tools = new StringTools(); System.out.println(tools.concat('-')); System.out.println(tools.concat('-',"hello")); System.out.println(tools.concat('-',"hello","world")); System.out.println(tools.concat('-',"hello","world","java")); } }运行结果：
2.特殊参数之二：命令行参数（了解）
想要了解的可以点击阅读，在此不再赘述。
方法的重载
方法重载：指在同一个类中，允许存在一个以上的同名方法，只要它们的参数列表不同即可，与修饰符和返回值类型无关。
重载方法调用：JVM通过方法的参数列表，调用匹配的方法。
先找个数、类型最匹配的
再找个数和类型可以兼容的，如果同时多个方法可以兼容将会报错
1、找最匹配的
public class MethodOverloadMosthMatch { public static void main(String[] args) { MathTools tools = new MathTools(); System.out.println(tools.max(5,3)); System.out.println(tools.max(5,3,8)); System.out.println(tools.max(5.7,2.5)); } }2、找唯一可以兼容的
public class MethodOverloadMostCompatible { public static void main(String[] args) { MathTools tools = new MathTools(); System.out.println(tools.max(5.7,9)); System.out.println(tools.max(5,6,8,3)); // System.out.println(tools.max(5.7,9.2,6.9)); //没有兼容的 } }3、多个方法可以匹配或兼容
public class MathTools { //求两个整数的最大值 public int max(int a,int b){ return a>b?a:b; } //求两个小数的最大值 public double max(double a, double b){ return a>b?a:b; } //求三个整数的最大值 public int max(int a, int b, int c){ return max(max(a,b),c); } //求n整数的最大值 public int max(int... nums){ int max = nums[0];//如果没有传入整数，或者传入null，这句代码会报异常 for (int i = 1; i < nums.length; i++) { if(nums[i] > max){ max = nums[i]; } } return max; } /* //求n整数的最大值 public int max(int[] nums){ //编译就报错，与(int... nums)无法区分 int max = nums[0];//如果没有传入整数，或者传入null，这句代码会报异常 for (int i = 1; i < nums.length; i++) { if(nums[i] > max){ max = nums[i]; } } return max; }*/ /* //求n整数的最大值 public int max(int first, int... nums){ //当前类不报错，但是调用时会引起多个方法同时匹配 int max = first; for (int i = 0; i < nums.length; i++) { if(nums[i] > max){ max = nums[i]; } } return max; }*/ }4、方法的重载和返回值类型无关
public class MathTools { public int getOneToHundred(){ return (int)(Math.random()*100); } public double getOneToHundred(){ return Math.random()*100; } } //以上方法不是重载
案例，用重载实现：
（1）定义方法求两个整数的最大值
（2）定义方法求三个整数的最大值
（3）定义方法求两个小数的最大值
（4）定义方法求n个整数最大值
public class MathTools { //求两个整数的最大值 public int max(int a,int b){ return a>b?a:b; } //求两个小数的最大值 public double max(double a, double b){ return a>b?a:b; } //求三个整数的最大值 public int max(int a, int b, int c){ return max(max(a,b),c); } //求n整数的最大值 public int max(int... nums){ int max = nums[0];//如果没有传入整数，或者传入null，这句代码会报异常 for (int i = 1; i < nums.length; i++) { if(nums[i] > max){ max = nums[i]; } } return max; } }
数组
一维数组
1.声明数组
dataType[] arrayRefVar; // 首选的方法
或
dataType arrayRefVar[]; // 效果相同，但不是首选方法
2. 创建数组
arrayRefVar = new dataType[arraySize];
3.同时声明与创建
dataType[] arrayRefVar = new dataType[arraySize];
或
dataType[] arrayRefVar = {value, value, ..., value};
4.For-Each 循环
JDK 1.5 引进了一种新的循环类型，被称为 For-Each 循环或者加强型循环，它能在不使用下标的情况下遍历数组。
语法格式如下：
for(数据类型 element： 数组名)
{
System.out.println(element);
}
public class TestArray {
public static void main(String[] args) {
double[] myList = {1.9, 2.9, 3.4, 3.5};
// 打印所有数组元素
for (double element: myList) {
System.out.println(element);
}
}
}
二维数组
1.声明数组
推荐
元素的数据类型[ ][ ] 二维数组的名称;不推荐
元素的数据类型 二维数组名[ ][ ];
或
元素的数据类型[ ] 二维数组名[ ];
2.创建数组
元素的数据类型[][] 二维数组的名称 = {
{元素1，元素2，元素3 。。。},
{第二行的值列表},
...
{第n行的值列表}
};
4066
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
