Java是一门面向对象的编程语言
在Java中，万事万物皆为对象;在Linux中，万事万物皆为文件
面向过程和面向对象
面向过程：面向过程就是分析出实现需求需要的步骤，通过一些方法一步一步实现需求
面向对象（行为化）：把整个需求的按照特点、功能划分，将这些存在共性的部分封装成类（类实例化之后才是对象），让对象去解决问题
举一个例子
要给客户买一个东西
面向对象：找一个店，买东西，不管是上架，还是东西，都是现实中真实存在的食物，这个商店或者东西我们就可以称之为对象，在整个买东西或上架卖东西，没有考虑东西是如何加工的
面向过程：找到原材料，字节切割，自己缝制，每一个工序都是自己干
其实，高级的编程语言，会向着人的思考靠近
面向对象更高级的抽象，是对显示世界的映射
String，Scanner，这就是别人给我们创建的对象
事实上我们也能自己创建对象，在开发中，我们基本上会大量的自己创建自己的对象
我们准备开一个4s店，我们需要有车，需要有门店
如果用代码去描述一辆车
车：描述信息，描述信息叫做属性，属性实际上从代码的角度来说就是变量
定义变量 brand color length问题又来了：怎么才能描述好几个车？
我们可能会需要几十个甚至上百个数组来维护一百辆车的信息，简直就是一个灾难
我们就要用面向对象的思想，我们将一个汽车的多个属性尝试进行打包面向对象的特征: 封装 继承 多态 抽象
如何“造车”
造车，需要图纸
根据图纸，可以造一百台车
这个图纸就是在描述车的具体信息，对车的信息的封装封装：
1.代码层面2.思想层面车的品牌、颜色、长度
若果把变量直接声明在类里：成员变量（全局变量）
如果把变量声明在某个方法里：局部变量 (成员变量->属性)
创建车属性
public class Car {
String brand; // 只声明，不赋值
String color;
long length;
// 这个类：描述汽车属性的类
}创建对象
public class Ch02 {
// 创建对象的过程，类的实例化的过程，对象又叫做类的一个实例
public static void main(String[] args) {
Car car1 = new Car();
car1.brand = "奥迪";
car1.color = "白色";
car1.length = 5L;
// 取出属性的值
System.out.println("生产了第1辆汽车，它的属性为"+car1.brand+","+car1.color+","+car1.length+"米");
Car car2 = new Car();
car2.brand = "丰田";
car2.color = "灰色";
car2.length = 4L;
System.out.println("生产了第2辆汽车，它的属性为"+car2.brand+","+car2.color+","+car2.length+"米");
}
}如果一个方法有static，想要调用一个非static的方法
就只能创建对象，使用对象
public class Ch01 {
public void run(){
}
public static void main(String[] args) {
Ch01 c = new Ch01();
c.run();
}
}斐波那契数列
什么是斐波那契数列？
斐波那契数列是[1,1,2,3,5,8,13,21]等等
每一个数字是前两个数字之和
需要先确定定义前两位数的值，再通过递归来计算
在函数方法内自己调用自己 直到找到前两位数的值
即f(num)=f(num-1)+f(num-2)
public class Ch01 {
/*
* 方法名不能重复
* 自己调用自己 递归
* 递归的问题： stackOverflowError 栈溢出 内存溢出
* */
public int fibonacci(int num) {
if (num <= 2) {
return 1;
}
return fibonacci(num - 1) + fibonacci(num - 2);
}
public static void main(String[] args) {
Ch01 c = new Ch01();
for (int i = 1; i <= 30; i++) {
System.out.print(c.fibonacci(i) + " ");
}
}
}使用递归求阶乘
与计算斐波那契数列相同，需要定义一个初始值
每次传参都要*=上一次的值
public int factorial(int num) {
if (num==1) { return 1; }
return factorial(num-1)*num;
}
public static void main(String[] args) {
Ch01 c = new Ch01();
System.out.println(c.factorial(5));
}方法重载
方法的重载 OverLoad
方法名相同、参数不同（参数的类型、参数的个数、参数的顺序）
放在同一个类
与返回值类型无关，与访问权限修饰符无关，与方法体无关方法重载的好处
把功能相似相同的方法放在一起
public void sum(int num1, int num2) {
System.out.println(num1 + num2);
}
public void sum(int num1,int num2,int num3) {
System.out.println(num1 + num2 + num3);
}
public void sum(double num1,double num2) {
System.out.println(num1 + num2);
}
public void sum(int num1,double num2) {
System.out.println(num1 + num2);
}
public void sum(double num1,double num2,double num3) {
System.out.println(num1 + num2 + num3);
}
public static void main(String[] args) {
Ch02 c = new Ch02();
c.sum(1,2,3.5);
}利用方法重载求最大值
写两个重载的方法
一个方法求两个数的最大值
另一个方法求三个数的最大值求三个数的最大值可以调用求两个数最大值的函数
public class Ch03 {
public int getMax(int num1, int num2) {
return num1 > num2 ? num1:num2;
}
public int getMax(int num1,int num2,int num3) {
return getMax((getMax(num1,num2)),num3);
}
public static void main(String[] args) {
Ch03 c = new Ch03();
System.out.println(c.getMax(5, 10,50));
}
}不定长参数
将一堆数字传入函数内，计算总和
sum参数列表中，最多有一个不定长参数
不定长参数必须在最后的位置
public int getSum(int ... arr) { // 不定长参数
if (arr.length < 2) { return arr[0]; }
int sum = 0;
for (int i : arr) {
sum+=i;
}
return sum;
}
public static void main(String[] args) {
Ch04 c = new Ch04();
System.out.println(c.getSum(1,2,3));
}访问权限
访问权限
public 一个工程下认识位置都可以访问
protected 可以跨包，必须是它的子类
default 当前包下可以访问
private 只有当前类才可以访问
构造器
构造器（构造方法）
语法：访问权限修饰符 类名（）{ }特点：
1、java在new对象的时候，先看对象所对应的类有没有构造器
如果没有构造器 则无法创建对象
2、每个类，都会有一个默认的构造器
3、在对象被实例化时，调用了构造器
4、创建对象实际上是通过构造器创建的
5、如果一个类中是显式的声明了一个构造器，原来默认自带的无参构造器就会失效
public class Ch06 {
public static void main(String[] args) {
// 创建对象的过程，实例化的过程，创建一个Dog类的实例
// 类名 对象吗 = new 构造器
Dog dog = new Dog("123");
}
}
public class Dog {
public Dog(String str) {
System.out.println("Dog构造器执行"+str);
}
}
1 条评论
看完一遍