（一）面向对象编程（OOP）
1. 什么是面向对象
2. 回顾方法及加深
2.1 方法的定义
- 修饰符
- 返回类型
- break：跳出Switch，结束循坏 和return 的区别
- 方法名：注意规范就OK 见名之意
- 参数列表：（参数类型 参数名，.....）
- 异常抛出：疑问，后面讲解
package com.oop;
import java.io.IOException;
//Demo01 类
public class Demo01 {
//main 方法
public static void main(String[] args) {
}
/*
* 修饰符 返回值类型 方法名(...){
* //方法体
* return 返回值;
* }
* */
public String sayHello() {
return "hello,world";
}
public int max(int a, int b) {
return a > b ? a : b; //三元运算符
}
// 數組下标越界：Arrayindexoutofbounds
public void readFile(String file) throws IOException{
}
}
2.2 方法的调用
- 静态方法
- 非静态方法
- 形参和实参
- 值传递和引用传递
- this关键字
package com.oop;
public class Demo02 {
public static void main(String[] args) {
//非静态方法
//实例化这个类 new
//对象类型 对象名=对象值;
Student student = new Student();
student.say();
//静态方法 static
//直接 类名.方法名 就可调用
//不用实例化
Student.say();
}
// 和类一起加载的
public static void a(){
// b(); 所以这里调用b就会报错
}
//类实例化 之后才存在
public void b(){
a();
}
}
package com.oop;
//学生类
public class Student {
//方法
public static void say(){
System.out.println("学士");
}
}
package com.oop;
public class Demo03 {
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;
}
}
package com.oop;
//值传递
public class Demo04 {
public static void main(String[] args) {
int a=1;
System.out.println(a);
Demo04.change(a);
System.out.println(a); //1
}
//返回值为空
public static void change(int a){
a=10;
}
}
package com.oop;
//引用传递：对象，本质还是值传递
// 对象，类
public class Demo05 {
public static void main(String[] args) {
Person person = new Person();
System.out.println(person.name); //null
Demo05.change(person);
System.out.println(person.name); //秦江
}
public static void change(Person person){
//person是一个对象：指向的----> Person person = new Person();
// 这是一个具体的人，可以改变属性！
person.name="秦江";
}
}
//定义了一个Person类，有一个属性：name
class Person{
String name;
}
3. 类与对象的创建
3.1 类与对象的关系
3.2 创建与初始化对象
package com.oop.demo02;
//学生类
public class Student {
//属性：字段
String name;
int age;
//方法
public void study(){
System.out.println(this.name+"在学习");
}
}
package com.oop.demo02;
//一个项目应该只存一个main方法
public class Application {
public static void main(String[] args) {
//类：抽象的，实例化
//类实例化后会返回一个自己的对象！
//student对象就是一个Student类的具体实例！
Student Tom = new Student();
Student July = new Student();
Tom.name="汤姆";
Tom.age=6;
System.out.println(Tom.name);
System.out.println(Tom.age);
July.name="朱莉";
July.age=6;
System.out.println(July.name);
System.out.println(July.age);
July.study();
}
}
3.3 构造器详解
特点：
- 和类名相同
- 没有返回值
作用：
- new 本质在调用构造方法
- 初始化对象的值
注意点：
- 定义有参构造之后，如果想使用无参构造，显示的定义一个无参的构造
快捷键：Alt+Insert
package com.oop.demo02;
//java----> class
public class Person {
//一个类即使什么都不写，它也会存在一个方法
//显示的定义构造器
String name;
int age;
//实例化初始值
//1.使用new关键字，本质实在调用构造器
//2.用来初始化值
public Person(){
}
//有参构造:一旦定义有参构造，无参构造必须显示定义
public Person(String name){
this.name=name;
}
//构造器的快捷键：alt+insert
public Person(String name, int age) {
this.name = name;
this.age = age;
}
}
//测试类
public static void main(String[] args) {
//new 实例化一个对象
Person person = new Person("qing");
System.out.println(person.name);
}
3.4 创建对象内存分析
4. 总结
-
类与对象：
类是一个模版：抽象，对象是一个具体的实例
-
方法
定义、调用
-
对应的引用
引用类型 基本类型（8）
对象是通过引用来操作的：栈----->堆
-
属性：字段Field 成员变量
默认初始化：
数字：0 0.0
char：u0000
boolean：false
引用：null
修饰符 属性类型 属性名 = 属性值
-
对象的创建和使用
- 必须使用new 关键字创建对象，构造器 Person xueqin = new Person();
- 对象的属性 xueqin.name
- 对象的方法 xueqin.sleep()
-
类：
静态的属性 属性
动态的行为 行为封装、继承、多态
