面向对象编程
Java的核心思想就是OOP，也就是面向对象编程。
面向对象编程的本质：以类的方式组织代码，以对象的形式封装数据。
三大特性：封装、继承、多态
回顾方法的定义
package com.oop.demo01;
import java.io.IOException;
//Demo01 类
public class Demo01 {
//main方法
public static void main(String[] args) {
}
//定义几个简单的类
/*
修饰符 返回值类型 方法名（方法的参数）{
//方法体
return 返回值;
}
*/
//return:结束方法，返回一个结果，结果可能为空，也可能为任意其他类型
//break:跳出switch，结束整个循环
//continue:跳出一个循环
public String sayHello(){//String 返回字符串
return "hello,world";
}
public void hello(){//void 没有返回的东西，默认返回值为空
return;
}
public int max(int a,int b){
return a>b ? a:b;//三元运算符
}
//数组下标越界：Arrayindexoutofbounds
//抛出异常 IO流读文件
public void readFile(String file) throws IOException{
}
}
回顾方法的调用
静态和非静态方法
package com.oop.demo01;
public class Demo02 {
//静态方法 static
//非静态方法
public static void main(String[] args) {
//调用非静态方法，必须先实例化这个类 new
//对象类型 对象名字 =对象值
Student student = new Student();//new Student();小太阳
student.say();
}
//两个普通方法，没有静态方法，a可以直接调用b();
//两个静态方法，a也可以直接调用b
//a为静态方法，b不是静态方法，则会报错
//static和类一起加载的
public static void a(){
b();
}
//类实例化后才存在，一个存在的东西调用一个还不存在的东西，所以会报错
public static void b(){
}
}
形参和实参
package com.oop.demo01;
public class Demo03 {
public static void main(String[] args) {
//new Demo03().add()第一种调用方法
//添加static改成静态方法
//1、2是实际参数，a、b是形式参数，实际参数和形式参数的类型要对应
int add = Demo03.add(1, 2);//Demo03.add(1,2)+小太阳
System.out.println(add);//输出3
}
public static int add(int a,int b){
return a+b;
}
}
值传递
package com.oop.demo01;
//值传递
public class Demo04 {
public static void main(String[] args) {
int a=1;
System.out.println(a);//1
Demo04.change(a);
System.out.println(a);//1
}
//返回值为空
public static void change(int a){//a是形式参数，没有返回结果,只在内部执行了a=10，并没有返回到主方法
a=10;
}
}
引用传递
package com.oop.demo01;
//引用传递：对象 本质还是值传递
public class Demo05 {
public static void main(String[] args) {
Person person = new Person();//如何使用Person这个类，实例化的过程 new Person();
System.out.println(person.name);//null
Demo05.change(person);
System.out.println(person.name);//yzx
//基本类型int传递的是数值，没有返回值所以输出的还是原来的值
//引用类型person首先是实例化了这个person对象，对象指向的是地址，改变地址会改变结果
}
public static void change(Person person) {
//person是一个对象：指向的—–>Person person = new Person();这是一个具体的人，可以改变属性
person.name = "yzx";
}
}
//定义了一个person类，有一个属性：name
class Person{
String name;//默认值为null
}
类与对象的关系
创建一个Student类
package com.oop.demo02;
//学生类
public class Student {
//属性：字段
String name;//没有赋值默认值是null
int age;//没有赋值默认值是0
//方法 this.name指代变化的学生名字，this代表当前的类
public void study(){
System.out.println(this.name+"在学习");
}
}
创建一个student对象
package com.oop.demo02;
//一个项目应该只存在一个main方法 应用类
public class Application {
public static void main(String[] args) {
//类：抽象的，需要实例化
//类实例化之后会返回一个自己的对象，返回结果
//student对象就是一个Student类的具体实例
Student student = new Student();
Student xiaoming = new Student();
Student xiaohong = new Student();
xiaoming.name="小明";//赋值
xiaoming.age=3;//赋值
System.out.println(xiaoming.name);//输出小明
System.out.println(xiaoming.age);//输出3
System.out.println(xiaohong.age);//输出null
System.out.println(xiaohong.age);//输出0
}
}
构造器详解
package com.oop.demo02;
//java—>class
public class Person {
//public Person(){}
//一个类即使什么都不写，它也会存在一个方法
//显示的定义构造器
//无参构造：没有参数的构造
String name;
//实例化初始值
//1、使用new关键字，本质是在调用构造器
//2、用来初始化值
public Person() {
this.name = "yzx";
}
//有参构造：一旦定义了有参构造，无参就必须显示定义，必须自己手动写一个无参构造，可以为空
public Person(String name){
this.name="name";//构造器可以给对象初始值赋值
}
//alt+inset 自动生成构造器
/*
构造器：
1、和类名相同
2、没有返回值，不能写void
作用：
1、new本质在调用构造方法
2、初始化对象的值
注意点：
1、定义有参构造之后，如果想使用无参构造，显示的定义一个无参的构造
*/
}
//主方法：
package com.oop.demo02;
//一个项目应该只存在一个main方法 应用类
public class Application {
public static void main(String[] args) {
//new 实例化了一个对象
Person person = new Person("yzx");//什么都没写依然能new一个Person，说明存在一个空的Person方法
System.out.println(person.name);//输出yzx
}
}
创建对象内存分析
package com.oop.demo03;
public class Pet {
public String name;
public int age;
//无参构造 默认有
public void shout(){
System.out.println("叫了一声");
}
/*
1、类与对象
类是一个模版，是抽象的，对象是一个具体的实例
2、方法
定义、调用
3、对象的引用
引用类型： 除了基本类型(8)之外
对象是通过引用来操作的：栈—>堆(指向对象中的地址)
4、属性：字段Field 成员变量
默认初始化：
数字：0 0.0
char：u0000
boolean：false
引用：null
属性的定义：修饰符 属性的类型 属性名=属性值
5、对象的创建和使用：
– 必须使用new关键字创造对象，必须有构造器 Person yzx=new Person();
– 对象的属性 yzx.name
– 对象的方法 yzx.sleep()
6、类：
静态的属性 属性
动态的行为 方法
三大特征：封装、继承、多态
*/
}
//主方法
package com.oop;
import com.oop.demo03.Pet;
public class Application {
public static void main(String[] args) {
Pet dog = new Pet();
dog.name="yun";
dog.age=3;
dog.shout();
System.out.println(dog.name);
System.out.println(dog.age);
}
}
