一.封装
1.this
1.当成员变量和局部变量重名时,调用遵循"就近原则",先调用局部的
2.this代表的是当前对象,哪个对象调用this所在的方法,this就代表哪个对象
3.作用:区分重名的成员变量和局部变量(this后面肯定是成员的)
public class Person {
String name;
/**
* 哪个对象调用的this所在的方法
* this就代表哪个对象
* @param name
*/
public void speak(String name){
System.out.println(this+"........this");
System.out.println(this.name+"您好,我是"+name);
}
}
public class Test01 {
public static void main(String[] args) {
Person person = new Person();
System.out.println(person+".....person");
person.name = "张三";
person.speak("李四");
System.out.println("===============");
Person person1 = new Person();
System.out.println(person1+".........person1");
person1.name = "王五";
person1.speak("赵六");
}
}
2.构造方法
1.空参构造方法
- new对象使用
- 没有返回值,没有void,方法名和类名一致
- new就调用,构造方法会自动执行
public person(){
}
每一个类jvm都会给一个默认的空参构造,不写也有
2.有参构造方法
- new对象使用
- 为属性赋值
- jvm不会提供有参构造,需要自己写
- 如果写了有参构造,jvm不再提供空参构造,需要自己补上去
public person(参数){
为属性赋值
}
//空参构造
public Person(){
}
//有参构造
public Person(String name,int age){
this.name = name;
this.age = age;
}
3.标准javabean
1.具有私有成员变量
2.有空参和有参构造方法
3.有get set方法
4.类必须是具体的(非抽象 abstract)和公共的,public class 类名
public class Person {
private String name;
private int age;
//无参构造
public Person(){
}
//有参构造
public Person(String name,int age){
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
二.static关键字
1.可以修饰一个成员变量,还可以修饰一个方法
2.特点
- 被static修饰的成员随着类的加载而加载
- 被static修饰的成员由于跟着类到内存,所以优先于对象存在
- 被static修饰的成员属于类成员,不属于对象成员(成员方法,成员变量)
- 根据static所在的类创建出来的对象,都会共享这个静态成员
3.使用
- 修饰成员变量: static 数据类型 变量名
- 修饰方法:
修饰符 static 返回值类型 方法名(参数){
方法体
return 结果
}
4.调用
- 类名直接调用
public class Student {
String name;
static String classRoom;
//静态的方法
public static void study(){
System.out.println("学生要学习");
}
}
public class Test01 {
public static void main(String[] args) {
//类名直接调用
Student.classRoom = "222";
Student s1 = new Student();
s1.name = "张三";
//s1.classRoom = "222";
System.out.println(s1.name);
System.out.println(s1.classRoom);
//类名直接调用
Student.study();
System.out.println("====================");
Student s2 = new Student();
s2.name = "李四";
//s2.classRoom = "222";
System.out.println(s2.name);
System.out.println(s2.classRoom);
//类名直接调用
Student.study();
}
}
1.static修饰成员访问特点
-
非静态的能直接访问静态成员
a.在同一个类中:直接调用,类名调用(实际上是直接调用),new对象调用(即使new对象调用的实际上也是直接调用的)
b.不在同一个类中:类名调用,new对象调用(实际上也是类名直接调用)
-
静态的能直接访问非静态成员
不能-> 静态成员随着类的加载而加载优先于非静态成员产生
但是new对象可以访问非静态成员
-
非静态能直接访问非静态成员
a.在同一个类中:直接调用,new对象调用
b.不在同一个类中:new对象调用
-
静态的能直接访问静态成员
a.在同一个类中:直接调用,类名调用,new对象调用
b.不在同一个类中:类名调用,new对象调用
总结:
1.不管在不在同一个类中,只要是访问静态的:都可以使用类名点
2.不管在不在同一个类中,只要是访问非静态的:都可以new对象调用
补充:
-
静态成员随着类的加载而加载,如果所有成员都变成静态的,会过多的占用内存
-
1.共享数据 2.抽取工具类时 可以使用静态方法
public class ArraysUtils {
//工具类不需要new对象调用,只需要类名调用,所以我们可以将构造方法变成私有的
private ArraysUtils(){
}
public static void print(int[] arr){
System.out.print("[");
for (int i = 0; i < arr.length; i++) {
if (i==arr.length-1){
System.out.print(arr[i]+"]");
}else{
System.out.print(arr[i]+", ");
}
}
}
}
public class Test02 {
public static void main(String[] args) {
int[] arr = {1,2,3,4,5};
ArraysUtils.print(arr);
}
}
public class Test03 {
public static void main(String[] args) {
int[] arr = {1,2,3,4,5,5,6,89,7,8,8,64};
ArraysUtils.print(arr);
}
}
三.可变参数
修饰符 返回值类型 方法名(非可变参数形参列表,参数类型. . . 形参名)
其实这个书写约等于
修饰符 返回值类型 方法名(非可变参数形参列表,参数类型[] 形参名)
- 一个方法最多有一个可变参数
- 如果一个方法包含可变参数,那么可变参数必须是形参列表的最后一个
例:n个字符串进行拼接,每一个字符串之间使用某字符进行分隔,如果没有传入字符串,那么返回空字符串""
public class Demo03{
public static void main(String[] args) {
String result = concat("-", "张无忌", "张翠山", "张三丰", "金毛狮王", "白眉鹰王", "青翼蝠王", "紫衫龙王");
System.out.println("result = " + result);
}
public static String concat(String s, String... arr) {
String str = "";
for (int i = 0; i < arr.length; i++) {
if (i == arr.length - 1) {
str += arr[i];
} else {
str += arr[i] + s;
}
}
return str;
}
}
四.递归
- 递归:指在当前方法内调用自己的这种现象。
- 递归的分类:
- 递归分为两种,直接递归和间接递归。
- 直接递归称为方法自身调用自己。
- 间接递归可以A方法调用B方法,B方法调用C方法,C方法调用A方法。
- 注意事项:
- 递归一定要有条件限定,保证递归能够停止下来,否则会发生栈内存溢出(因为会不断的压栈)。
- 在递归中虽然有限定条件,但是递归次数不能太多。否则也会发生栈内存溢出。
示例一:需求:利用递归输出3到1
public class Demo01 {
public static void main(String[] args) {
method(3);
}
public static void method(int n) {
if(n==1){
System.out.println(n);
return;
}
System.out.println(n);
n--;
method(n);
}
}
示例二:求n!
public class Demo02 {
public static void main(String[] args) {
int result = method(4);
System.out.println("result = " + result);
}
private static int method(int n) {
if(n==1){
return 1;
}else{
return n*method(n-1);
}
}
}