面向对象编程OOP
面向
面向对象和面向过程
面向对象oop-分类的思维方式-本质——以类的方式组织代码，以对象的组织（封装）数据
抽像+封装+继承+多态
认识上-先有对象（具体的事物）再有类（对对象的抽象） 代码上-先有对象再有类（类是对象的模板）
面向过程-线性步骤分析方式
类-描绘一系列事物的共同特征并将它抽象出来-比如哺乳动物
对象-具体的示例-比如人
使用new关键字创建对象-分配内存空间
默认初始化
对类中的构造器（必须掌握）进行调用
构造器-构造器又叫构造方法，在进行创建对象时必须要调用的
-
必须和类的名字相同
-
必须没有返回类型，也不能写void
总结
1、类与对象
类是一个抽象的模板，对象是一个具体的实例
2、方法
定义，调用
3、对应的引用
引用类型：基本类型（8）以外
对象是通过引用来操作的：具体的栈，而真实属性是在堆中
4、属性：字段field 成员变量
默认初始化：数字-0，char-u000，boolean-false，引用-null
赋值-修饰符 属性类型 属性名 = 属性值；
5、对象的创建和使用
- 必须使用new关键字创造对象，且必须有构造器 Person moulixu = new Person();
- 对象的属性 mouixu.name
- 对象的方法 moulixu.sleep()
6、类
静态的属性 属性
动态的行为 方法
方法
1、回顾方法定义
//回顾方法定义
package oop;
public class a1 {
// main方法
public static void main(String[] args) {
}
/* 方法定义
修饰符 返回值类型 方法名（参数类型和参数名）{
方法体；
return 返回值；
}
注：1、方法名-驼峰原则和见名知意
2、返回数值应该和定义类型相同
3、参数可定义多个
4、return和break
return代表运算结束返回结果，不再执行下一行代码；返回数值应该和定义类型相同
break跳出switch,结束循环
*/
public String sayHello(){
return "Hello,World";
}
//空方法
public void hello(){
return;
}
//比大小
public int max(int a,int b){
return a>b?a:b;//三元运算符，是就a,不是就b
}
}
2、回顾方法的调用-递归
/* 回顾方法的调用-递归
*/
package oop;
public class a2 {
public static void main(String[] args) {
//同态可以调用，不同态不可以
//静态方法+static
a3.say();
//非静态方法
//实列化这个类new; 对象类型 对象名 = 对象值；
a3 a3 = new a3();
a3.print();
//实际参数和形式参数的类型要一一对应！
int add = a2.add(3,5);
System.out.println(add);
//值传递
int a=1;
System.out.println(a);//输出值唯1
a2.change(a);
System.out.println(a);//输出值也为1
//引用传递：传递一个对象，本质还是值传递
Person person = new Person();
System.out.println(person.name);//null
a2.cite(person);
System.out.println(person.name);//牟李旭
}
public static int add(int a,int b){
return a+b;
}
//返回值为空
public static void change(int a){
a=10;
}
public static void cite(Person person){
//person是一个对象，指向的Person person = new Person();这是一个具体的人，可以改变属性
person.name="牟李旭";
}
}
//一个类里面可以有多个class 但只能有一个public
//定义了一个Person类，有一个属性name
class Person{
String name; //默认值为null
}
/*
//辅助学习方法的调用
package oop;
import java.sql.SQLOutput;
public class a3 {
//静态方法
public static void say(){
System.out.println("静态方法");
}
public void print(){
System.out.println("非静态方法");
}
}
*/
3、类和new的使用
package oop;
//学生类-类是一个抽象的模板，通过new关键字创造具体的实例
//以类的方法组织代码，以对象的方式封装程序
public class a4 {
//类里面只有属性和方法
// 属性 字段
String name;//默认null
int age;//默认零
//方法
public void study(){
System.out.println(this.name+"学生在学习");//this.就表示当前这个类
}
}
/* new的使用
package oop;
//一个项目应该只存在一个main方法
public class Application {
public static void main(String[] args) {
//类是抽象的，通过new需要实例化
//类实例化后会返回一个自己的对象！
//a4对象就是一个a4类的具体实例!-记住以后类的首字母大写
a4 xiaoming = new a4();
a4 wangyi = new a4();
//a4中的是模板为空的，需要定义才能使用
System.out.println(xiaoming.name);//输出为null
System.out.println(xiaoming.age);//输出为0
xiaoming.name ="小明";
xiaoming.age =18;
System.out.println(xiaoming.name);//输出为null
System.out.println(xiaoming.age);//输出为0
}
}
*/
4、构造器的使用
/* 构造器的使用
alt+insert会生成构造器，根据选择形成 select null生成无参
1、使用new关键字，本质是在调用构造器
2、用来初始化值
*/
package oop;
public class Application {
public static void main(String[] args) {
//使用new实例化了一个对象，即使原函数中什么都没有
People people1 = new People();//一旦定义了有参定义，无参就必须显示定义,否则使用不了
People people2 = new People("xiaohei");//就会默认走有参构造器
System.out.println(people1.name);
System.out.println(people2.name);
}
}
/*
//辅助理解构造器使用的理解
package oop;
/*
java自动生成的class文件
用idea打开class文件， 项目结构-Moduls-增加目录-加入out-点击ok和applay-out中生成class文件有构造器
结论1、一个类即使什么也不写，也会存在一个方法打开clss可以看到
2、也可以自己定义构造器
都必须遵守两条规则
（1）. 必须和类的名字相同
（2）. 必须没有返回类型，也不能写void
3、this.表示当前这个类，后面跟参数
注意点：定义有参构造以后，如果想使用一个无参构造，特别的定义一个无参构造
*/
public class People {
String name;
//实例化初始值
//显示的定义构造器
//无参构造器
public People(){
this.name = "xiaobai";
}
//有参构造器：一旦定义了有参定义，无参就必须显示定义
public People(String name){
this.name =name;//this.name表示的是类，而后面的name表示的是参数
}
}
*/