java对象
面向过程，面向对象
-
面向过程思想：步骤清晰，第一步做什么，第二部做什么；
面向对象：以分类的思维模式，思考解决问题需要哪些分类，适合处理复杂的问题。
面向对象编程（OOP）的本质：以类的方式组织代码，以对象的组织（封装）数据。
抽象：就是要把很多对象的共有的特点剥离抽取出来，再把它变成一个类。比如：studentmanager中学生都有的姓名，学号，班级，我们把很多学生的共同点剥离抽取出来，形成一个类，就叫做抽象（像）。
三大特性：封装：把代码中的数据封装起来，对外留一个口让外部访问；
继承：子类，父类；
多态：一个类中不同对象执行同一个方法会得出不一样的结果。
从认知论的角度考虑：先有对象，后有类。对象，是具体的事物（比如小明，小红）；类是抽象的，是对对象的抽象（比如：人[小明，小红都属于人]）。
从代码的角度考虑：先有类，后有对象。类是对象的模板（比如用模具造东西）。通过new创建对象（关键字）。
属性加方法构成一个类。
回顾方法的定义
代码一：
package oop.demo01;
public class Demo01 {
//main方法 启动当前程序
public static void main(String[] args) {
}
public String say(){
return "sayhi";
System.out.println("1"); //无效的表达式，return代表方法已经结束了，已经得到返回值。
}
public void say1(){
return; //默认返回值为空
}
public int max(int a,int b){
return a>b ? a : b; //如果a>b，返回a，否则返回b。（三元运算符）
}
}
break：跳出switch case；结束循环。continue：结束一次循环。
return：代表方法结束。
方法名：首字母小写，驼峰原则，见名知意。
参数列表：参数类型 参数名 （形参...）
异常抛出：后期更新。public void readFile(String file) throws IOException{}
数组下标越界：Arrayindexoutofbounds
回顾方法的调用
递归
代码二：
package oop.demo01;
public class Demo02 {
public static void main(String[] args) {
Student.say(); //静态static方法，直接通过类名.方法名进行调用
//实例化这个类 new
//new Student().say(); new 创建了Student这个类，并调用了say方法。
//对象类型 对象名 = 对象值；（对象值变成了实例化对象这样一个过程） （与下一行一一对应）
Student student = new Student();
student.say(); //对象名.方法 非静态方法的调用
}
//同一类下的两个非静态方法，在这个类中可以互相调用
//同一类下的两个静态方法，也可以互相调用
//如果a是静态方法，b不是静态方法，a无法调用b方法，因为一个已经存在的东西去调用一个不存在的东西，所以不能调用。
public static void a(){ //静态方法是和类一起加载的
b();
}
public void b(){ //b方法是对象创建之后才存在，通过new，类实例化之后才存在
}
}
Student类：
package oop.demo01;
public class Student {
//静态方法
public static void say(){
System.out.println("学生说话了");
}
//非静态方法
public void say(){
System.out.println("学生说话了");
}
}
代码三：形参和实参
package oop.demo01;
public class Demo03 {
public static void main(String[] args) {
Demo03 demo03 = new Demo03();
//实际参数和形式参数的类型要一致
int sum = demo03.sum(1,2);
System.out.println(sum);
}
public int sum(int a,int b){
return a+b;
}
}
值传递和引用传递：
代码四：
package 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){ //main中的实参只是把1赋给形参中的a，形参中的a变成10，但并没有返回给main中的实参
a = 10;
}
}
代码五：
package oop.demo01;
//引用传递：一般是传递一个对象，本质还是值传递
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); //zhangsan
}
public static void change(Person person){
//person是一个对象，指向的是Person这个类--->Person person = new Person();这是一个具体的人，所以可以改变属性（不是形参）。
person.name = "zhangsan"; //指向的是Person类中的name，所以可以修改
}
}
//一个类中只能有一个public class，可以有很多class
class Person{ //定义了一个Person类，有一个属性：name
String name;
}
this关键字：代表当前这个类或者当前这个对象。
创建对象
类与对象的关系：类是一种抽象的数据类型，它是对某一类事物整体描述/定义，但并不能代表某一具体事物。比如：动物（猫，狗都属于动物），手机（有很多种牌子）等。
对象是抽象概念的具体实例。比如：张三就是人的一个具体实例，张三家里的旺财就是狗的一个具体实例。而不是抽象的概念。
使用new 关键字创建对象：使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用（与类名相同的方法的调用）。
类是一个抽象的模板，通过new关键字可以创建不同的具体的实例，可以把世界上所有人都想成是一个人的模板。Person-->身高，体重，年龄，对世界进行抽象化
代码一：Application
package oop.demo01.demo02;
//一个项目应该只存在一个main方法
public class Application {
public static void main(String[] args) {
//类：抽象的，把它实例化
//类实例化后会返回一个自己的对象
//所以student对象就是一个Student类的具体实例。
Student student = new Student(); //new Student（）就是这个类就被实例化了，实例化之后会产生一个返回结果。
Student xiaoming = new Student(); //同一个类可以产生不同的对象。但都有共同的特性。比如：都有名字，年龄。
xiaoming.name = "小明";
xiaoming.age = 3;
System.out.println(xiaoming.name);
System.out.println(xiaoming.age);
System.out.println(student.name);
}
}
代码二：Student
package oop.demo01.demo02;
//一个程序只有一个主启动类main
public class Student {
//属性：字段
String name; //默认是null,抽象的概念，不应该被写死，String name = xiaoming;
int age; //默认是0
//方法：
public void study(){
System.out.println(this.name+"在学习"); //当前这个类的指向名字学生在学习
}
}
构造器详解：类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的，并且有两个特点：一是必须和类的名字相同；二是必须没有返回类型，也不能些void。
代码一：
package oop.demo01.demo02;
//java文件-->class文件
public class Person {
//显示的定义构造器
String name;
//构造器可以实例化一些对象的初始值
//1.使用new关键字，必须要有构造器，本质是在调用构造器
//2.构造器一般用来初始化值
public Person() { //默认加了个方法，还没有返回值；方法名和类名相同 （无参构造器）
this.name = "zhangsan"; //实例化就是一个方法，构造器（方法）走完了，然后Person person = new Person();这句话才生成对象
} //一个类即使什么都不写，也会存在一个方法，这个方法就叫做构造器（构造方法）。
//有参构造：一旦定义了有参构造，如果想使用无参构造，无参就必须显示定义，否则无参方法无效。 （重载）
public Person(String name){
this.name = name; //前面的this.name代表对象本身的name（上面这个类的），后面的name代表形参String name传递下来的name。
}
//alt+insert 生成构造器 一键生成
//选择constructor-->choose field to initalize by constructor-->nameString-->ok;无参的话直接select none。
}
代码二：
package oop.demo01.demo02;
//一个项目应该只存在一个main方法
public class Application {
public static void main(String[] args) {
//new 实例化了一个对象
Person person = new Person(); //直接进入public Person() {}方法 （调无参方法）
Person zhangsan = new Person("zhangsan"); //通过new关键字去调相应的构造方法（调有参方法）
System.out.println(person.name); //zhangsan
}
}
创建对象内存分析
代码一：
package oop.demo01.demo03;
public class Application { //程序运行是要加载一些程序运行的模板
public static void main(String[] args) {
Pet dog = new Pet(); //new了这个对象，调用了Pet类中的无参构造，生成了这个对象Pet dog。（对象的模板加载进来，之后生成一个具体的对象dog）（生成模板给的返回值，给新的对象）
dog.name = "旺财"; //对这些属性赋值
dog.age = 3;
dog.shout();
System.out.println("dog.name");
System.out.println("dog.age");
}
}
代码二：
package oop.demo01.demo03;
public class Pet {
public String name;
public int age; //public权限较高
//存在一个无参构造
public void shout(){
System.out.println("叫了一声");
}
}
总结类与对象
-
类与对象：类是一个模板，抽象；对象是一个具体的实例
-
方法：定义，调用
-
对象的引用：
引用类型：除去基本类型（8大基本类型）之外的都可以称为引用类型。
对象是通过引用来操作的（引用：指向对象的地址），引用栈里面的对象，真实的东西指向到堆里。
-
属性：field字段 也叫成员变量；默认会初始化；数字：0，0.0 char:u0000 boolean:false 引用：null。
定义方式：修饰符 属性类型 属性名 = 属性值。
-
方法：避免方法死循环
-
对象的创建和使用：必须使用new关键字创造对象，构造器； Person zhangsan = new Person(); (new了这样一个人，这个人肯定有构造方法，它会返回一个人这个对象，这个对象的名字随意取)
对象的属性: zhangsan.name
对象的方法：zhangsan.sleep();
7.
