一、面向对象
1、面向对象的三大特征
- 封装
- 继承
- 多态
如果要说是四大特征就多加：抽象性
2、类(Class)和对象(Object)是面向对象的核心概念。
- 类是对一类事物的描述，是抽象的、概念上的定义。重点就是类的设计(比如我们人类，是有哪些特征等等)
- 对象是实际存在的该类事物的每个个体，因而也称为实例(instance)。
类就好比如是：人类
对象：实实在在的我
如下：创建PersonTest类，其中有属性有方法：
package com.object; /* @USER PPL-泡泡龙 or 广深小龙 @date 2020-12-20 12:42 */ public class Person { public static void main(String[] args) { PersonTest p1 = new PersonTest(); p1.name = "ppl"; p1.age = 18; p1.isMale = true; p1.eat(); p1.sleep(); p1.talk(); } } class PersonTest { // 属性 String name; int age; boolean isMale; // 方法 public void eat() { System.out.println("人吃什么？答：人间烟火"); } public void sleep() { System.out.println("人需要睡觉休息，专家建议每天睡眠至少8小时"); } public void talk() { System.out.println("人可以说话，但我说的是中文"); } }
3、类属性(成员变量)与局部变量
也意味着作用域不一样。
特别需要注意：局部变量在调用前是没有初始值，所以一定要在调用前初始化值，除了形参以调用时传入；
package com.object; /* @USER PPL-泡泡龙 or 广深小龙 @date 2020-12-20 12:15 */ public class ObjectTest { public static void main(String[] args) { User user = new User(); user.name = "泡泡龙"; user.age = 18; user.eat("米饭"); } } class User { // 类的变量 String name; int age; public void eat(String food) { System.out.println("姓名：" + name + " 吃的是什么？ 答案：" + food); System.out.println("年龄只有：" + age); String IsMale = "true"; // 方法的变量（局部变量） System.out.println("我是局部变量：" + IsMale); } }
4、类的方法声明
- pubilc String xx：定义了返回值为String类型，就一定要有String返回值；
- pubilc String xx(String xxx){}：形参xxx，可以多个形参，逗号分开，调用该方法时传入；
- 方法中也可以调用类的属性；
- return既是结束这个方法执行，并返回值；(结束后面不可再执行，因已结束方法)；
- 在类中的方法A它可以调用方法B等等，特殊的递归，方法A调用方法A；(慎用递归)
- 方法中，不能再定义方法；(Python里面是可以的，常用装饰器便如此)
package com.object; /* @USER PPL-泡泡龙 or 广深小龙 @date 2020-12-20 16:20 */ public class ClassM { public static void main(String[] args) { ClassTest m = new ClassTest(); m.eat("米饭"); System.out.println(m.name); System.out.println(m.getName()); System.out.println(m.returnName()); // 引用类型 ClassTest[] st = new ClassTest[3]; st[0] = new ClassTest(); System.out.println("111" + st[0].name); } } class ClassTest { // 类属性 String name = "泡泡龙"; // 形参：food，可以多个逗号分开 public void eat(String food) { System.out.println("吃的是：" + food); } // 有返回值：return，需指定返回的类型，比如：String // 但是命名指定了返回值的类型，就一定要有：return返回值 public String getName() { eat("面条"); // 方法内部调用方法 return name; } // 判断语句，需要在各个分支都要return public String returnName() { if ("泡泡".contains(name)) { return name; } else if ("泡泡龙".contains(name)) { return "1"; } else { return "-1"; } } }
输出：
吃的是：米饭
泡泡龙
吃的是：面条
泡泡龙
1
111泡泡龙
5、匿名实例化对象
在实例化中，没有赋值给一个变量，即为匿名实例化；
特征：只能调用一次（再调用就是新的调用，内存解析会重新执行）new ClassName().方法名；
package com.object; /* @USER PPL-泡泡龙 or 广深小龙 @date 2020-12-20 17:47 */ public class Instance { public static void main(String[] args) { // 正常实例化 PersonT p = new PersonT(); p.GetAge(); // 匿名实例化 new PersonT().GetAge(); } } class PersonT { int age = 8; public void GetAge() { System.out.println(age); } }
6、方法重载
同一个类，相同的方法名，参数不同包括形参个数,不同参数的类型。跟起它都没有关系，比如返回值，修饰符等。
简单来说处理不同数据类型的时候，可以定义不同类型，同名称的方法，方便我们任何类型进行调用。
package com.object1220; /* @USER PPL-泡泡龙 or 广深小龙 @date 2020-12-20 19:47 */ public class OverLoad { // 方法重载，定义两个同名的方法：print public String print(String str) { return str; } public int print(int num) { return num; } } class OverLoadTest { public static void main(String[] args) { OverLoad o = new OverLoad(); System.out.println(o.print("字符串")); System.out.println(o.print(666)); } }
7、可变个数形参方法
格式：public void 方法名(数据类型... 变量名){}
- 也是可以形成方法重载，但也得遵循重载原来的规则；
- 传参时可以传入多个，通过变量名下标获取或者遍历获取所以传入的参数；
- 只能命名一个数据类型的可变个数形参；
package com.object1220; /* @USER PPL-泡泡龙 or 广深小龙 @date 2020-12-20 20:18 */ public class Args { // 可变个数形参 public void eat(String... food) { // 遍历可变形参 String strs = ""; for (int i = 0; i < food.length; i++) { strs += food[i] + " "; } System.out.println(strs); } public void eat(String food) { System.out.println("重载：" + food); } public void eat(int count) { System.out.println("重载，每天吃几次？：" + count); } public static void main(String[] args) { Args a = new Args(); a.eat("1", "2", "3", "PPL"); a.eat("米饭"); a.eat(3); } }
输出：
1 2 3 PPL
重载：米饭
重载，每天吃几次？：3
二、递归
递归方法：一个方法内调用它自身(方法调方法)，递归有它的一个深度，不然就和死循环没什么区别；
1、例子：计算1-100之间所有自然数之和;用递归实现；
package com.object1223;
/*
@USER PPL-泡泡龙 or 广深小龙
@date 2020-12-23 22:13
*/
public class Recursion {
public static void main(String[] args) {
/*
1、递归方法：一个方法内调用它自身(方法调方法)
*/
Recursion rec = new Recursion();
System.out.println(rec.getNumber(100));
}
// 计算1-100之间所有自然数之和;
public int getNumber(int i) {
if (i == 1) {
return 1;
} else {
return i + getNumber(i - 1);
}
}
}
就比如斐波那契也是利用递归，递归是一种算法，一种解决问题的思路；
2、其它面试题
题一：
/*
* 定义一个int型的数组:{10, 3, 234, 234, 12, 123, 34, 86};
* 让数组的每个位置上的值去除以首位置的元素，得到的结果，作为该位置上的新值。遍历新的数组。
*/
package com.interview;
/*
@USER PPL-泡泡龙 or 广深小龙
@date 2020-12-21 21:36
*/
import java.util.Arrays;
public class Interview1 {
public static void main(String[] args) {
int[] arr = {10, 3, 234, 234, 12, 123, 34, 86};
// for (int i = 0; i < arr.length; i++) { // 错误写法
// 方法一：倒着来可以的
for (int i = arr.length - 1; i >= 0; i--) {
arr[i] = arr[i] / arr[0];
}
System.out.println(Arrays.toString(arr));
// 方法二：用变量来先赋值下标为0的数值
int[] arr2 = {10, 3, 234, 234, 12, 123, 34, 86};
int temp = arr2[0];
for (int i = 0; i < arr.length; i++) {
arr2[i] = arr2[i] / temp;
}
System.out.println(Arrays.toString(arr2));
}
}
题二： // 需要在method调用后仅打印出a=100,b=200；(method是你要写的处理逻辑)
package com.interview;
/*
@USER PPL-泡泡龙 or 广深小龙
@date 2020-12-21 21:51
*/
public class Interview2 {
public static void main(String[] args) {
int a = 10;
int b = 10;
// 需要在method调用后仅打印出a=100,b=200；
method(a, b);
System.out.println("a=" + a);
System.out.println("b=" + b);
}
public static void method(int a, int b) {
a = a * 10;
b = b * 20;
System.out.println("a=" + a);
System.out.println("b=" + b);
System.exit(0);
}
}
题三：看以下程序，说出程序运行后输出的内容，ps：char类型是直接输出内容；
package com.interview;
/*
@USER PPL-泡泡龙 or 广深小龙
@date 2020-12-21 22:00
*/
public class Interview3 {
public static void main(String[] args) {
int[] arr = new int[10];
System.out.println(arr); // 输出地址值
char[] arr1 = new char[2];
System.out.println(arr1); // 为啥是空？
char[] arr2 = {'a', 'b'};
System.out.println(arr2); // 输出的是 a b
}
}
感谢尚硅谷在B站开源教学视频提供学习，欢迎来大家QQ交流群一起学习：482713805