当前位置 博文首页 > zhouqiyuan1233的博客：Java面向对象编程
视频教程链接
宏观方面需要面向对象的思想，但是微观就要使用面向过程的思想。
java面向对象编程（oop）
面向对象特征：
修饰符 ： static
静态方法：使用static修饰符
类可以直接调用另外一个类中的静态方法
–
非静态对象：
要 new 其他的类后才能使用其中的非静态方法。
–
在同个类中，不同的静态方法能互相调用，不同的非静态方法也能互相调用，非静态方法可以调用类中的静态方法，但是静态方法不能调用类中的非静态方法，因为二者的加载机制不同，static修饰的静态方法是和当前的类同时加载，非静态方法不是和类同时加载，静态方法相比非静态方法加载的时间要靠前一些。（听了狂神老师的课，这仅是个人理解，后面继续学习会补充这方面的知识）
非静态方法互相调用：
静态方法互相调用：
静态方法调用非静态方法：
非静态方法调用静态方法：
值传递：
//值传递
public class Demo03 {
public static void main(String[] args) {
int a = 1;
System.out.println(a);
Demo03.change(a);
System.out.println(a);
}
public static void change(int a) {
a = 10;
}
}
结果：
发现第二次输出 a 的值并没有发生改变，可见当使用值传递向 change 函数传递变量 a 时，**只是传递了 a 的值。**所以实际参数 a 的值没有改变。
–
引用传递：
//引用传递
public class Demo04 {
public static void main(String[] args) {
Person person = new Person();
System.out.println(person.name);
Demo04.change(person);
System.out.println(person.name);
}
public static void change(Person person) {
person.name = "zqy";
}
//定义了一个Person类，有个name属性
static class Person {
String name;
}
}
运行结果：
change 函数中传递的参数是 Person 并且该函数修改了 Person 函数中的属性 name。
使用 new 创建对象
public class Application {
//一个项目应该只有一个main方法
public static void main(String[] args) {
//使用 new 对抽象的类进行实例化
Student zns = new Student();
Student zqy = new Student();
zns.name="伞兵1号";
zns.age=1;
System.out.println(zns.name);
System.out.println(zns.age);
zqy.name="伞兵2号";
zqy.age=2;
System.out.println(zqy.name);
System.out.println(zqy.age);
}
}
//学生类
public class Student {
//属性，字段
String name;
int age;
//方法
public void study() {
System.out.println(this.name + "在学习！！");
}
}
先写个方法，里面啥也不加：
public class Person {
}
使用另外一个启动类的main方法实例化并启动：
public class Application {
public static void main(String[] args) {
//使用 new 对抽象的类进行实例化
Person person = new Person();
}
}
发现成功运行，没有报错。
查看Person的编译文件：
和java文件对比，发现被自动添加了一个方法，这个方法就是构造方法。
–
也可以手动写显示构造器：（无参构造器）
public class Person {
public Person(){
}
}
1.实例化初始值（为变量进行初始化）
public class Person {
String name;
public Person() {
this.name = "zqy";
}
}
–
2.使用 new 时，本质是去自动调用类中的构造器
–
注意：如果定义了有参构造，就一定要写显示构造器（否则会报错）：
写了显示构造后：
–
idea 生成构造器快捷键 alt+ins
–
构造器重载：
Application类：
public class Application {
public static void main(String[] args) {
Pet dog = new Pet();
dog.name = "旺财";
dog.age = 3;
System.out.println(dog.name);
System.out.println(dog.age);
Pet cat = new Pet();
}
}
Pet类：
public class Pet {
String name;
int age;
public void shout(){
System.out.println("叫了一声");
}
}
1.当使用 new 去实例化一个对象时，先经过方法内的无参构造
2.加载类，加载类中的main方法、常量
3.执行main方法，将main方法压入到栈中（main方法是最先被压入栈的，所以说，当栈中的main方法被释放后，就可以认为这个方法已经结束）
4.加载 new 的类（实例化），加载被实例化类的属性和方法（类似于加载这个类，并把它当做模板，通过这个模板生成一个对象）
例：当 new 一个dog时，第一步，在堆中分配各 new 的这个方法一块内存并分配地址，将模板存入这个内存，第二步，将dog压入栈，并指向堆中分配的内存块
5.进行赋值时，堆中的变量直接引用方法中传入的值。由于shout( ) 没有参数，所以直接调用Pet类中的方法。
6.当又new了一个cat，同样，先在栈内分配内存获取地址，并且存入模板。栈内压入cat。并指向堆内的新分配的堆内存。
总体：
主要思想：
–
关键字： private 与 public对应
私有化的属性不能直接通过实例化后的方法进行访问，需要使用get和set方法。
–
使用get和set
idea 自动生成get、set方法（快捷键 alt+ins）：
set方法，给这个变量赋值，get方法获取到这个变量的值
//private 属性私有
public class Student {
private String name;
private int id;
//需要提供一些可以操纵这些属性的方法 get/set
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
}
public class Application {
public static void main(String[] args) {
Student s1 = new Student();
s1.setName("马牛逼");
System.out.println(s1.getName());
}
}
结果：
–
通过 get set 方法能够对数据进行过滤：
public class Application {
public static void main(String[] args) {
Student s1 = new Student();
s1.setAge(500);
System.out.println(s1.getAge());
}
}
public class Student {
private int age;
public int getAge() {
return age;
}
public void setAge(int age) {
if (age > 120 || age < 0) {
this.age = 3;
} else {
this.age = age;
}
}
}
–
封装的意义：
