初始面向对象
面向过程思想
- 线性思维,步骤清晰
面向对象思想
- 物以类聚,分类的思维模式(属性+方法 = 类),首先思考问题的解决需要哪些分类
- 适合处理复杂问题
- 本质:以类的方法组织代码,以对象的组织(封装)数据
- 三大特性:封装、继承、多态
- 从认识角度:先有对象后有类
- 代码运行角度:先有类后有对象
方法的回顾与加深
新定义的方法写在类里面,main方法外面
方法定义
//demo01 是一个类
public class demo01 {
//main 方法 用于启动程序
public static void main(String[] args) {
}
/*
修饰符 返回值类型 方法名字(){
//方法体
return 返回值};
* */
//结束方法,返回一个结果
public String sayHello(){
return "hello world!";
}
public void hello(){
return;//void类型表示,返回值类型为空
}
//比大小,a b为形式参数
public int max(int a,int b){
return a>b?a:b;//三元运算符
};
}
方法的调用
- 静态方法
创建类
//学生类
public class Student {
//方法
public static void say(){
System.out.println("学生说话了");
}
}
调用类格式:类名.方法()
import com.oop.demo01.Student;
public class demo02 {
//静态方法 static
public static void main(String[] args) {
Student.say();
}
}
- 非静态方法
创建类
//学生类
public class Student {
//方法
public void say(){
System.out.println("学生说话了");
}
}
- 调用类
//学生类
public class Student {
//方法
public void say(){
System.out.println("学生说话了");
}
}
值传递
//值传递
public class demo04 {
public static void main(String[] args) {
int b = 1;
System.out.println(b);//1
System.out.println("=================");
demo04.change(b);
System.out.println(b);//1
}
//返回值为空
public static void change(int a){
a = 10;
}
}
引用传递
//引用传递:对象,本质是值传递
public class demo05 {
public static void main(String[] args) {
Person person = new Person();
System.out.println(person.name);//null
System.out.println("================");
demo05.change(person);
System.out.println(person.name);//lqy
}
public static void change(Person person){
//person是一个对象,指向Person person = new person();是一个具体的人,可以改变属性
person.name="lqy";
}
}
//定义了Person类,有一个属性:name
// (一个java文件只能有一个public class类,但可以有很多个class类)
class Person{
String name;//默认值是null
}
对象的创建与分析
- 类与对象的关系:
类:抽象的数据类型
对象:抽象概念的具体实例
对象的创建:关键字new
public class Student {
//属性:字段
String name;
int age;
//方法
public void study(){
System.out.println(this.name+"在学习");
}
}
调用类实例化
public class Application {
//一个项目应该只存一个main方法
public static void main(String[] args) {
//类:抽象的,需要实例化
//类实例化后会返回一个自己的对象!
//student对象就是一个Student类的具体实例
Student xiaoming = new Student();
Student xh = new Student();
xiaoming.name = "xiaoming";
xiaoming.age = 3;
System.out.println(xiaoming.name);
System.out.println(xiaoming.age);
xh.name = "xh";
xh.age = 5;
System.out.println(xh.name);
System.out.println(xh.age);
}
}
构造器
alt+insert—> Constructor 生成构造器
点击 OK 生成有参的构造器,点击 Select None 生成无参的构造器
//java--->class
public class Person {
//一个类即使什么都不写,也会存在一个方法
//显示定义构造器
String name;
//实例化初始值
//构造器作用:1.使用new关键字,本质是在调用构造器
//2.构造器用来初始化值
public Person(){//无参构造器
this.name = "lqy";
}
//有参构造:一旦定义了有参构造,无参就必须显示定义
public Person(String name){
this.name = name;//前一个name表示对象本身的name,后一个name是参数传递下来的name
}
}
实例化对象时会根据是否传入参数判断跑哪个构造器
- 无参构造器
public class Application {
//一个项目应该只存一个main方法
public static void main(String[] args) {
//new 实例化一个对象
Person person = new Person();
System.out.println(person.name);
}
}
//输出lqy
- 有参构造器
ublic class Application {
//一个项目应该只存一个main方法
public static void main(String[] args) {
//new 实例化一个对象
Person person = new Person("hello, world");
System.out.println(person.name);
}
}
//输出hello, world
创建对象内存分析
public class Pet {
public String name;
public int age;
//无参构造
public void shout(){
System.out.println("叫了一声");
}
}
调用
import com.oop.demo03.Pet;
public class Application {
public static void main(String[] args) {
Pet dog = new Pet();
dog.name = "旺财";
dog.age = 16;
dog.shout();
System.out.println(dog.name);
System.out.println(dog.age);
}
}
总结
- 类与对象:类是一个模板:抽象,对象是一个具体的实例
- 方法,定义、调用
- 对象的引用
基本类型(8个)
引用类型:对象是通过引用来操作的栈—>堆 - 属性:即字段
默认初始化
数字:0 0.0
char:u0000
boolean:false
引用:null
属性的定义:修饰符 属性类型 属性名 = 属性值 - 对象的创建和使用
必须使用new关键字创建对象 new 类名(); //alt+enter
对象的属性:对象名.属性名;
对象的方法:对象名.方法名(); - 类
静态属性 属性
动态的行为