面向过程 & 面向对象 回顾方法 20241231

面向过程 & 面向对象 20241231

面向过程思想

步骤清晰简单，第一步做什么，第二步做什么.….面对过程适合处理一些较为简单的问题 （线性思维）

面向对象思想

物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索

面向对象适合处理复杂的问题，适合处理需要多人协作的问题!

对于描述复杂的事物，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。

但是，具体到微观操作，仍然需要面向过程的思路去处理。

属性+方法===》类

什么是面向对象

• 面向对象编程(Object-Oriented Programming, OOP)

• 面向对象编程的本质就是:以类的方式组织代码，以对象的组织(封装)数据。

• 抽象 把像的东西抽取出来

三大特性:

1. 封装
2. 继承
3. 多态

◆从认识论角度考虑是先有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象

◆从代码运行角度考虑是先有类后有对象。类是对象的模板。

回顾方法和加深：

1. 修饰符：public 权限修饰符 static 静态的
2. 返回值类型：void无返回值类型，四类八种，string，或者自定义的
3. break：结束整个循环，跳出switch；continue：结束本次循环； return：结束方法体，返回一个结果
4. 方法名：注意规范，简明知意，就ok
5. 参数列表：（参数类型，参数名） ... 可变参数
6. 异常抛出

package com.oop.demo01;
import java.io.IOException;
//Demo01  类
public class Demo01 {
//main方法
public static void main(String[] args) {      
    /*{
         //方法体
         return  返回值;
         //return作用：结束方法，返回一个结果。结果可以是任意类型(与返回值类型对应)的数据，也可以为空(void)。
         //return代表方法体的结束，return下面的代码unreachable statement无效的语句;
         //return返回一个结果，与返回值类型相同的结果.也可以不带参数，返回值类型为void
         //break代表跳出循环，跳出switch; continue代表结束本次循环。
     }*/
	}
public String sayHello() {
    return "Hello,World！";
	} 
public void print() {
    return;
	}
public int max(int a, int b) {
    return a > b ? a : b;//三元运算符
	}
//数组下标异常  ：ArrayIndexOutOfBoundsException:
public void readFile(String file)throws IOException{

	}
}

方法的调用：递归

1. 静态方法：被static修饰的方法，从属于类，随类加载 ，可以借助类名直接调用

2. 非静态方法：除静态方法以外的方法，从属于对象，实例化后才可调用

package com.oop.demo01;
//静态方法 直接类名就可以调用 如第7行
//非静态方法 必须要构建对象 如第11行（构建对象）、12行调用非静态方法
public class Demo02 {
public static void main(String[] args) {
//静态方法：直接类名.方法名调用即可
	Student.say();
//非静态方法：
//实例化这个类,对象类型 对象名 = 对象值；
//然后对象名.方法名调用
	Student student = new Student();
	student.joke();
	}
//被static修饰的方法是和类一起加载的，从属于类。
//静态的只能调用静态的方法
public static void a() {
	b();
	}
public static void b() {
 
	}
//类实例化之后才存在，非静态方法从属于对象
public void c() {

	}
}

package com.oop.demo01;
//学生类
public class Student {
     //静态方法
     public static void say() {
         System.out.println("学生说话了");
     }
     //非静态方法
     public void joke() {
         System.out.println("学生爱开玩笑");
     }
 }

• cal_demo01

package com.oop.demo01;
//回顾方法
//函数之间的相互调用， 此例都是用的静态方法，可以相互调用
//注意，静态方法不能直接调用非静态方法
public class Demo01 {
    public static void main(String[] args) {
        System.out.println(chengjia(2,3,4));
    }
    public static int add(int a, int b) {
        return a+b;
    }
    public static int cheng(int a, int b) {
        return a*b;
    }
    public static int chengjia(int a, int b,int c) {
        int temp =add(a,b);
        temp=cheng(temp,c);
        return temp;
    }
}

• cal_demo02

package com.oop.demo01;
//讨论下静态方法、非静态方法之间的调用
//如第九行 静态方法调用非静态方法（不被允许）  报错
//第15行  非静态方法调用静态方法（是被允许的）
public class Demo02 {
    public static void main(String[] args) {

    }
    public static int add(int a, int b) {
        //print_hello();
        return a + b;
    }
    public void print_hello(){
        System.out.println("hello");
        System.out.println(add(1,2));//这是被允许的
    }
}

• 形参和实参：实际参数(具体的值)和形式参数(它只是一个名字)的类型要对应！

package com.oop.demo01;
public class Demo03 {
public static void main(String[] args) {
//实际参数(具体的值)和形式参数(它只是一个名字)的类型要对应！
	Demo03 demo03 = new Demo03();
	int add = demo03.add(1, 2);
	System.out.println(add);
	int i = Demo03.subtractExact(1, 2);
	System.out.println(Demo03.subtractExact(1, 2));
	}
public int add(int a, int b) {
	return a + b;
	}
public static int subtractExact(int a, int b) {
	return a - b;
	}
}

• 值传递和引用传递：

package com.oop.demo01;
//值传递
public class Demo04 {
	public static void main(String[] args) {
		int a = 1;
		System.out.println(a);//1 
		Demo04.change(a); 
		System.out.println(a);//1
     }
//返回值为空
	public static void change(int a) {
		a = 10;
     }
}

package com.oop.demo01;
//引用传递：传递一个对象，本质还是值传递
public class Demo05 {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person.name);//null
        Demo05.change(person);
        System.out.println(person.name);//雷伟
    }
    public static void change(Person person) {
    	person.name = "雷伟";
    }
}
//一个类只能有一个public class，可以有多个class
//定义了一个Person类;有一个属性:name
class Person {
String name;//null
}

小总结

1. 我想知道类带不带public 的区别
2. 方法我已经懂了，静态的方法，包括main方法（也是一种静态方法）不能调用非静态方法，必须要实例化对象后才能使用，非静态方法可以调用静态方法和非静态方法。
3. 我最后面这个类带了public 是不是不对，IDEA跳出提示让我新建 Student.java,是不是一个java文件里只让定义一个 public的类啊？

1.类带不带 public 的区别：

• public 类：如果一个类是 public，它的访问权限是完全开放的，可以被其他包中的类访问。但一个 Java 文件中只能有一个 public 类，并且这个 public 类的名字必须与文件名相同。
• 非 public 类：没有 public 修饰符的类（即包级私有类）只能在同一个包内访问。这种类可以有多个，而且它们的名字可以与文件名不同。

例如，以下代码是合法的：

// Student.java
class Student {
    // 这是没有 public 修饰符的类
}
public class Teacher {
    // 这是 public 修饰符的类
}

如果你把 Teacher 类改为 public，那么这个文件必须命名为 Teacher.java，否则会出现编译错误。

静态方法与非静态方法的调用：

• 静态方法：静态方法属于类本身，而不是某个对象。它可以直接通过类名来调用，比如 Teacher.print_hello()。静态方法不能访问类中的非静态成员变量或方法
• 非静态方法：非静态方法属于类的实例（对象）。它可以访问类中的静态成员和非静态成员。所以你可以在非静态方法中调用静态方法和其他非静态方法。

举个例子：

class Teacher {
    static void print_hello(String msg) {
        System.out.println(msg);
    }

    void print_hello_instance() {
        print_hello("Hello from instance method!"); // 调用静态方法
    }
}
public class Demo03 {
    public static void main(String[] args) {
        Teacher teacher = new Teacher();
        teacher.print_hello_instance(); // 正确：通过实例调用非静态方法
        Teacher.print_hello("Hello from static method!"); // 正确：通过类名调用静态方法
    }
}

关于 Java 文件中是否只能定义一个 public 类：

• 是的，一个 Java 文件中只能有一个 public 类。并且这个 public 类的名字必须与文件名一致。所以，你的 Student 类应该放在单独的 Student.java 文件中，或者去掉 public 修饰符（即改为包级私有类），然后在同一个文件中定义多个类。

修改后的代码：

// Teacher.java
public class Teacher {
    String name;
    static void print_hello(String name) {
        System.out.println("Hello, " + name);
    }
}
// Student.java
class Student {
    String name;
}

如果你尝试将 Student 类放在 Teacher.java 文件中并加上 public 修饰符，IDE 会提示你错误，要求你将 Student 类放到一个新的文件 Student.java 中，因为每个 Java 文件中只能有一个 public 类。