1、面向对象
概述：如今主流的软件开发思想有两种：面向过程与面向对象。面向过程较早，典型代表为C语言，用于开发中小型项目。面向对象较晚，典型代表为C++与Java等，使用与大型开发场景。
面向过程的思想：当需要实现一个功能的时候，看中的是每一个步骤怎么做，整体的过程是怎么样的，每个操作都需要亲力亲为。
面向对象的思想：当需要实现一个功能的时候，不看重具体的过程与步骤，只关系谁可以帮我做这件事情（偷懒，找人帮做事）
面向对象的三大特征：封装性、继承性、多态性。
package xwg.Eric.study.second;
import java.util.Arrays;
public class ObjectExperience {
public static void main(String[] args) {
int[] array = { 10, 20, 30, 40, 50 };
System.out.print("["); // 面向过程
for (int i = 0; i < array.length; i++) {
if (i == array.length - 1) {
System.out.println(array[i] + "]");
} else {
System.out.print(array[i] + ", ");
}
}
System.out.println("=============");
String str = Arrays.toString(array); // 面向对象
System.out.println(str);
System.out.println(Arrays.toString(array));
}
}
2、类与对象的关系
面向对象的语言当中，类是用来模拟现实事物。类也有属性、行为两个部分，对象是类的具体实例。类是抽象的，对象是具体的。
类包括两部分：（1）成员变量：属性，将变量位置直接定义在类中没在方法外，即为成员变量。
（2）成员方法：行为，将普通的方法去掉static关键词，即成为成员方法。
创建对象：格式：类名称 变量名称 = new 类名称(); Student stu = new student();
使用成员变量：对象名称.成员变量(参数)； stu.name
使用成员方法：对象名称.方法名； stu.eat
总结：通过对象名称，想用谁就.谁
类是一种引用数据类型，使用有三个步骤：
（1）导包：在同一个包中使用时不需要导包
（2）创建：类名称 对象名称 = new 类名称（）；
（3）使用：使用成员变量：对象名称.成员变量(参数)； stu.name
使用成员方法：对象名称.方法名； stu.eat
package xwg.Eric.study.object;
public class StudentNew {
String name;
int age;
public void eat() {
System.out.println("吃饭！");
}
public void sleep() {
System.out.println("睡觉!");
}
public void study() {
System.out.println("打豆豆!");
}
public static void main(String[] args) {
Student stu = new Student();
System.out.println(stu.name);
System.out.println(stu.age);//如果成员变量没有赋值，则赋予默认值。
System.out.println("=====================");
stu.name = "小宝贝最美，永远" + 18 + "岁";
stu.age = 18;
System.out.println(stu.name);
System.out.println(stu.age);
stu.eat();
stu.sleep();
stu.study();
}
}
关于对象的内存图：
创建类及其使用流程（一个对象【new】），以上图为例【new几次创建几个对象】
首先新建一个类，其中成员变量有brand、price、color；成员方法有call、sendMessage。创建的类首先保存在方法区中，同样main方法也在方法区中存储，程序启动时，先加载main方法。新建的类中的成员变量与成员方法（new出来的）首先存放在堆（Heap）中，当main方法调用新建的类时，使用成员变量时，在main中调用并赋值给相关的成员变量，存放在堆中的成员变量将其默认值改为main中赋予的值，回传给main；使用成员方法时，main通过新建类的地址找到其在堆中的存放位置，通过堆中存放成员方法的地址找到在方法区中定义类的地址，通过地址找到对应的成员方法，成员方法进行入栈操作，入栈后执行完毕对应方法的功能，随后出栈。对于创建两个对象，在堆中new出来两个不同地址的对象，其中两个对象的成员方法指向方法区中同一地址的成员方法。
使用同一个对象：
public static void main(String[] args) {
Student stu1 = new Student();
System.out.println(stu1.name);
System.out.println(stu1.age);//如果成员变量没有赋值，则赋予默认值。
System.out.println("=====================");
stu.name = "小宝贝最美，永远" + 18 + "岁";
stu.age = 18;
System.out.println(stu1.name);
System.out.println(stu1.age);
stu1.eat();
stu1.sleep();
stu1.study();
Sustem.out.println（“====================”）
//对同一对象进行调用
Student stu2 = stu1;//调用对象stu1；
System.out.println(stu2.name);//调用对象stu1，使得将堆中对stu1的赋值作为默认值打印
System.out.println(stu2.age);
System.out.println("=====================");
stu2.name = "小宝贝最美，永远" + 18 + "岁";
stu2.age = 18;
System.out.println(stu2.name);
System.out.println(stu2.age);
stu2.eat();
stu2.sleep();
stu2.study();
}
使用同一对象与使用一个对象不同点在于Student stu2 = stu1；调用对象stu2时使用stu1new出来的值作为默认值使用。
3、局部变量与成员变量的区别
| 局部变量 | 成员变量 | |
|---|---|---|
| 定义位置 | 方法内部，包括成员方法的参数 | 直接定义在类中（方法外） |
| 内存中的位置 | 栈内存（Stack） | 堆内存（Heap） |
| 生命周期 | 随着方法的进栈出现，随着方法的出栈消失（短） | 随着对象被创建出现，随着对象被JVM垃圾回收而消失（长） |
| 默认值 | 没有默认值，赋值后使用 | 如果不赋值就有一个默认值（根据定义类型来确定其初始默认值） |
4、private：确保数据安全
在定义Person时，其中的age年龄不应该为负数，但是却无法控制取值范围，所以数据不安全
解决方法：使用private关键字，当使用private关键字进行修饰，超出类的范围之外，就不可以直接访问。但是可以采用间接访问，访问时需要使用setter、getter方法
定义类：使用关键字private使得数据有一定的安全性，只有符合private的要求才可以输入。
package xwg.Eric.study.object;
public class TestPrivate {
String name;
private int age;
String love;
public void person(){
System.out.println("我叫" + name + ",今年" + age + "岁了" + "我最爱的人是" + love);
}
public void setAge(int num){
if(num < 0 || num >=200){
System.out.println("这是假的，小宝贝永远18岁");
}else{
age = num;
}
}
public int getAge() {
return age;
}
}
使用类：
package xwg.Eric.study.object;
import java.util.Scanner;
public class Person {
public static void main(String[] args) {
TestPrivate person = new TestPrivate();
Scanner input = new Scanner(System.in);
System.out.println("请输入name");
person.name = input.next();
System.out.println("请输入age");
int age = input.nextInt();
System.out.println("请输入love");
person.love = input.next();
person.setAge(age);
person.person();
}
}
5、this：解决重名问题
当局部变量和成员变量重名时，方法会根据“就近原则”使用变量。如果想要区分局部变量和方法变量，需要使用this加以区分。this关键词代表的是“当前对象”，通过谁调用谁的方法，谁就是this。
格式：this.成员变量
package xwg.Eric.study.object;
//方法定义
public class ThisKind {
String name;
public void This(String name){
System.out.println(name + ",hello! I am " + this.name);
}
}
package xwg.Eric.study.object;
//调用方法
public class This {
public static void main(String[] args) {
ThisKind baby = new ThisKind();
baby.name = "乐哥哥";
String name = "little baby";
baby.This(name);
}
}
6、构造方法
构造方法就是专门用来创建对象的方法，当通过new关键字创建对象时，实质就是在调用构造方法
定义格式：public 构造方法名 （参数类型 参数名称）{
方法体;
return; //可以省略
}
调用格式：类名称 对象名称 = new 构造方法名称（）；
注意：构造方法法不能写返回值类型，连void都不能写；构造方法的名称必须和所在类名称完全相同；构造方法也可以重载；构造方法如果没有自定义，那么类将会赠送一个（创建对象时不会报错），如果自定义了至少一个，不再默认赠送
//定义一个类，没有构造方法
public class Name(){
}
//调用构造方法
public class MakeName(){
public static void main(String[] args){
Name one = new Name(); //m默认创建一个构造方法
}
}
//执行结果为空白7、定义标准类（POJO：Plain Old Java Object）
（1）所有成员变量使用private关键字私有化
（2）为每一个成员变量编写一对Getter、Setter方法
（3）编写一个无参数的构造方法
（4）编写一个全参数的构造方法
构造方法写在成员变量后
package xwg.Eric.study.object;
public class DefineStandardKind {
private String name;
private int age;
//构造方法
//构造无参数的构造方法
public DefineStandardKind(){
}
//构造有参数的构造方法
/*
*source-->Generate Constructor using fields
*自动生成有参数的构造方法
*/
public DefineStandardKind(String name, int age) {
super();
this.name = name;
this.age = age;
}
//source-->Generate Getters and Setters-->select all 自动生成getters and setters
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;
}
}
对于所有的数据类型，Getter都必须叫getxxx，setter都必须叫setxxx，但是有一个特例，对于布尔类型的变量，setxxx不变，getxxx需要变为isxxx的形式
private boolean male;
//同样可以使用source-->Generate Getters and Setters-->select all 自动生成getters and setters
public boolean isMale() {
return male;
}
public void setMale(boolean male) {
this.male = male;
}
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
