目录
1.什么是面向对象
1.面向过程&面向对象
1.面向过程思想
2.面向对象思想
2.什么是面向对象
2.方法回顾与加深
1.方法的定义
2.方法的调用
1.静态、非静态
2.形式参数、实际参数
3.值传递引用传递
3.创建对象分析
1.类与对象的创建
1.类
2.对象
2.构造器
3.创建对象内存分析
4.面向对象小结
Java的核心思想就是OOP
面向对象编程(Object-Oriented Programming, OOP)
面向对象编程的本质就是:以类的方式组织代码,以对象的组织(封装)数据。
抽象 封装继承多态<抽象类<接口
三大特性:
- 封装
- 继承
- 多态
从认识论角度考虑是先有对象后有类。对象,是具体的事物。类,是抽象的,是对对象的抽象
从代码运行角度考虑是先有类后有对象。类是对象的模板。
方法的定义
- 修饰符
- 返回类型
- break:跳出switch,结束循环和return:结束方法,返回一个结果 的区别
- 方法名:注意规范:驼峰命名法 见名知意
- 参数列表:(参数类型,参数名)...
- 异常抛出:try{}catch{}
方法的调用
- 静态方法
- 非静态方法
- 形参和实参
- 值传递和引用传递
- this关键字:当前对象本身
//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{
}
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("学生说话了");
}
}
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;
}
值传递
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.默认是空
}
使用new关键字创建对象
使用new关键字创建的时候,除了分配内存空间之外,还会给创建好的对象进行默认的初始化
以及对类中构造器的调用。
package java_jichu.mianxiangduixiang.demo1;
//学生类 类是来组织代码的
public class Student {
//属性:字段
String name;//null
int age;//0
//方法
public void study(){
System.out.println(this.name+"在学习");
}
}
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
}
}
类中的构造器也称为构造方法,是在进行创建对象的时候必须要调用的。
特点:
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);
}
}
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.封装、继承、多态