javaSE入门：面向对象(一)
目录
1.什么是面向对象
Java的核心思想就是OOP
1.面向过程&面向对象
1.面向过程思想
- 步骤清晰简单，第一步做什么，第二步做什么...
- 面对过程适合处理一些较为简单的问题
2.面向对象思想
- 物以类聚,分类的思维模式，思考问题首先会解决问题需要哪些分类,然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索。
- 面向对象适合处理复杂的问题，适合处理需要多人协作的问题!
- 对于描述复杂的事物，为了从宏观上把握、从整体上合理分析,我们需要使用面向对象的思路来分析整个系统。但是，具体到微观操作,仍然需要面向过程的思路去处理。
2.什么是面向对象
面向对象编程(Object-Oriented Programming, OOP)
面向对象编程的本质就是:以类的方式组织代码，以对象的组织(封装)数据。
抽象 封装继承多态<抽象类<接口
三大特性:
- 封装
- 继承
- 多态
从认识论角度考虑是先有对象后有类。对象,是具体的事物。类,是抽象的，是对对象的抽象
从代码运行角度考虑是先有类后有对象。类是对象的模板。
2.方法回顾与加深
方法的定义
- 修饰符
- 返回类型
- break:跳出switch，结束循环和return：结束方法，返回一个结果 的区别
- 方法名：注意规范：驼峰命名法 见名知意
- 参数列表：（参数类型，参数名）...
- 异常抛出：try{}catch{}
方法的调用
- 静态方法
- 非静态方法
- 形参和实参
- 值传递和引用传递
- this关键字：当前对象本身
1.方法的定义
//main方法
public static void main(String[] args) {
}
/*
修饰符 返回值类型 方法名（...）{
方法体
return 返回值；
}
返回值与返回类型必须一致，
return：结束方法返回一个结果！ 写return的时候就已经结束了，在后面写什么都会报错
*/
public static String sayHello(){
return "hello,world";
}
public void hello(){
return; //可加可不加，因为没有返回值，它是默认存在的
}
public int max(int a,int b){
return a>b ? a : b;
}
//异常
//数组下标越界：ArraylndexOutOfBoundsException
public void readFile(String file) throws IOException{
}2.方法的调用
1.静态、非静态
package java_jichu.mianxiangduixiang;
//二、方法的调用
public class Demo02 {
public static void main(String[] args) {
//实例化这个类new
//对象类型 对象名 = 对象值;
Student student = new Student();
student.say(); //学生说话了
}
//一、静态方法
//static是和类一起加载的
public static void c(){
//b();//一个存在static调用一个不存在static的方法所以会报错
}
//没有static的是类实例化之后才存在的
public void a(){
}
public void b(){
}
}
package java_jichu.mianxiangduixiang;
public class Student {
//非静态化方法
public void say(){
System.out.println("学生说话了");
}
}2.形式参数、实际参数
public static void main(String[] args) {
//实际参数和形式参数的类型要对应
//实际参数
int add = Demo03.add(1,2);
System.out.println(add);
}
//形式参数
public static int add(int a, int b){
return a+b;
}3.值传递引用传递
值传递
public static void main(String[] args) {
int a=1;
//一
System.out.println(a); //1
Demo04.change(a);
System.out.println(a); //1因为他的返回值为空，就只是个形式参数，所以还是调用实际参数的a
System.out.println(chage(a));//报错，因为方法的返回值是空
//二
Demo04.change(a);
System.out.println(a);//1虽然说有了返回类型，但是只是获取到了方法的形式参数，最后还是实际参数赋值，然后输出1
System.out.println(chage(a));//10调用了chage方法里的a
}
//一
//返回值为空
public static void change(int a){
a=10;
}
//二
public static int change(int a){
a = 10;
return a;
}引用传递
package java_jichu.mianxiangduixiang;
// 引用传递: 对象，本质还是 值传递
public class Demo05 {
public static void main(String[] args) {
Perosn perosn = new Perosn();//1.去调用Perosn的无参构造器
System.out.println(perosn.name); //2. 4.null
Demo05.change(perosn);//5. 7.使用自己类下的change方法来给perosn的对象name赋值
System.out.println(perosn.name); //8.琴疆
}
public static void change(Perosn perosn) {
//perosn是一个对象:指向的---> Perosn perosn = new Perosn();这是一个具体的人，可以改变属性!
perosn.name ="秦疆";//6.
}
}
//定义了一个Perosn类,有一个属性: name
class Perosn{//默认访问修饰符：自己和自己同包内可以访问这个类
String name; //null 3.默认是空
}3.创建对象分析
1.类与对象的创建
使用new关键字创建对象
使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化
以及对类中构造器的调用。
1.类
package java_jichu.mianxiangduixiang.demo1;
//学生类 类是来组织代码的
public class Student {
//属性:字段
String name;//null
int age;//0
//方法
public void study(){
System.out.println(this.name+"在学习");
}
}
2.对象
package java_jichu.mianxiangduixiang.demo1;
//一个项目应该只存一个main方法 每个具体对象来封装具体的数据
public class Application {
public static void main(String[] args) {
//类：开始抽象的，需要给他实例化
//类实例化后会返回一个自己的对象
//student对象就是一个Student类的具体实例！
Student xiaoming = new Student();
Student xh = new Student();
xiaoming.name="小明";//给新创建的对象赋值
xiaoming.age=3;
System.out.println(xiaoming.name);//小明
System.out.println(xiaoming.age);//3
System.out.println(xh.name);//null 没有给新创建的对象赋值，就输出默认值
System.out.println(xh.age);//0
}
}2.构造器
类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。
特点：
1.名字和类名相同
2.没有返回值3.生成类的对象时自动执行，无需调用
作用：
2.初始化对象
注意点：
1.定义有参构造之后，如果想使用无参构造，显式的定义一个无参构造2.多个构造器之间是重载关系，规则和方法重载一致(参数个数不同或参数类型不同)
3.每个类都会默认有一个构造器（这个构造器隐式存在）（默认的构造器为无参构造器，当定义有参构造的时候无参构造器消失）
4.父类的构造器不会被子类继承
5.new本质在调用构造方法（调用构造方法，创建新的对象）
快捷键：
fn+alt+insert
package java_jichu.mianxiangduixiang.demo1;
//java -->class默认在out里生成了一个class文件 构造器
public class Person {
//一个类即使什么都不写，他也会存在一个方法
//显示定义的构造器
String name;
int age;
//实例化初始值
//1.使用new关键字,必须要有构造器
//2.构造器一般用于初始化值
//无参构造(默认构造器) 构造器默认是不显示的，但是有
//fn+alt +insert ->select None(无选择)
public Person(){
// this.name="qinjiang";//用于给类中的成员变量name赋值，也可以直接在成员变量赋值
}
//有参构造(重载构造器):一旦定义了有参构造，默认的无参构造就消失了(如果要用，就必须把无参构造显示出来)
// fn+alt +insert ->ok
public Person(String name){
this.name=name;
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public static void main(String[] args) {
//new 实例化了一个对象 有参构造 调用自己的类直接用有参构造的参数列表的内容赋相应的值
Person persons = new Person("shuangma",23);
System.out.println(persons.name);//shuangma
//无参构造 调用自己类 让给自己类的值一个一个赋值
Person person = new Person();
person.name="shuangma2";
person.age=2;
System.out.println(person.name);
}
}
3.创建对象内存分析
4.面向对象小结
1.类与对象
类是一个模板：抽象，对象是一个具体的实例
例：类是女孩 对象：女孩的状态（名字、年龄...）和行为（说话、吃...）
2.方法
定义、调用！
例（定义）：修饰符 返回值类型 方法名（参数类型 参数名）{} 异常 break和return
例（调用）：静态方法、非静态方法、形参和实参、值传递和引用传递、this关键字
3.对象的引用（面向对象图3）
引用类型：除了 基本类型（八大基本类型）以外都是引用类型
对象是通过引用来操作的：栈-->堆
4.属性：字段Field 成员变量
默认初始化
数字： 0 0.0
char： u000
boolean：false
引用：null
定义
修饰符 属性类型 属性名 = 属性值
5.对象的创建和使用
必须使用new关键字创造对象，构造器 Person kuangshen = new Person();
对象的属性 kuangshen.name
对象的方法 kuangshen.sleep()
6.类：
静态的属性 属性
动态的行为 方法
7.封装、继承、多态