java学习笔记（八）

java学习笔记（八）

开始学习java，并养成写博客的习惯，希望能够坚持下去,有志同道合的小伙伴可以一起学习java基础

二十三 面向对象

面向过程 & 面向对象

什么是面向对象

• 面向对象编程的本质：以类的方式组织代码，以对象的方式组织（封装）数据。
• 抽象：提取不同对象的共同点
• 三大特性：封装、继承、多态
• 从认识的角度是先有对象后有类
• 从代码角度时候现有类后有对象

方法的定义

package mifan.oop;

import java.io.IOException;

public class Demo01 {
    public static void main(String[] args) {

    }
    /*
    修饰符  返回值类型  方法名（。。。）{
         方法体
         return 返回值
    }
    * */
    public String sayHello(){
        return "Hello";
    }

    public void hello(){
        return;
    }

    public int max(int a,int b){
        return a>b ? a:b;//三元运算符
    }

    public void readFile(String file)throws IOException{

    }
}

方法的调用

package mifan.oop;

public class Demo02 {
    public static void main(String[] args) {
        Student.say();//静态
        Student student = new Student();//非静态
        student.say1();

    }
    //静态方法是跟类一起加载的
    public static void a(){

    }
    //非静态方法是类实例化之后才存在的
    public  void b(){
        a();//非静态方法可以调用静态方法，反之不行
    }
}

package mifan.oop;

public class Demo03 {
    public static void main(String[] args) {
        Demo03 demo03 = new Demo03();
        int add = demo03.add(1,3);
        System.out.println(add);
    }

    public int add(int a,int b){
        return a+b;
    }
}

package mifan.oop;
//值传递
public class Demo04 {
    public static void main(String[] args) {
        int a = 1;
        System.out.println(a);
        change(a);
        System.out.println(a);
    }
    //返回值为空
    public static void change(int a){
        a = 10;
    }
}

package mifan.oop;
//引用传递：对象，本质还是值传递
public class Demo05 {
    public static void main(String[] args) {
        Person person = new Person();

        System.out.println(person.name);//null

        change(person);

        System.out.println(person.name);
    }
    public static void change(Person person){
        person.name = "mifan";
    }
}

//定义一个person类，有一个属性：name
class Person{
    String name;//null
}

类与对象的创建

• 类是一种抽象的数据类型，它是对某一类事物的整体描述/定义，但是并不能代表某一个具体的事物。
• 对象是抽象概念的具体实例

package mifan.oop.Demo02;
//一个项目应该只存在一个main方法
public class Application {
    public static void main(String[] args) {

        //类：抽象的，实例化
        //类实例化后会返回一个自己的对象！
        //student对象就是一个Student类的具体实例！
        Student mifan = new Student();
        Student xiaohong = new Student();

        mifan.name = "mifan";
        mifan.age = 18;
        System.out.println(mifan.name);
    }
}

package mifan.oop.Demo02;
//学生类
public class Student {
    //属性、字段
    String name;
    int age;

    //方法
    public void study() {
        System.out.println(this.name+"学生在学习");
    }
}

构造器详解

package mifan.oop.Demo02;
//一个项目应该只存在一个main方法
public class Application {
    public static void main(String[] args) {

        Person person = new Person();
       }
}

package mifan.oop.Demo02;

public class Person {
    //一个类即使什么都不写，它也会存在一个构造器
}

.class文件
package mifan.oop.Demo02;

public class Person {
    //默认生成构造器
    public Person() {
    }
}

package mifan.oop.Demo02;
//一个项目应该只存在一个main方法
public class Application {
    public static void main(String[] args) {

        Person person = new Person();
        Person person1 = new Person("mifan");
        System.out.println(person.name);
        System.out.println(person1.name);
       
    }
}

package mifan.oop.Demo02;

public class Person {
    //一个类即使什么都不写，它也会存在一个构造器

    //显示的定义构造器
    String name;
    int age;

    //使用new关键字本质是在调用构造器
    //用来初始化值
    public Person(){

    }

    //有参构造：一旦定义了有参构造，无参就必须是显式定义，不可不写
    public Person(String name){
        this.name = name;
    }

    //alt + insert 创建构造器 快捷键
    /*构造器：
        1.和类名相同
        2.没有返回值
      作用：
        1.使用new关键字本质是在调用构造器
        2.用来初始化值
      注意点：
        1.定义有参构造之后，如果想使用无参构造，显式的定义一个无参的构造

    * */

}

小结

1. 类与对象
   类是一个模板、抽象
   对象是一个具体实例

2. 方法 定义调用

3. 对应的引用
   引用类型： 基本类型（8）
   对象是通过引用来操作的：栈—》堆

4. 属性：字段Field 成员变量
   默认初始化：
   数字： 0 0.0
   char: u0000
   boolean:false
   引用：null

5. 对象创建与使用
   必须使用new关键字创造对象 Person xiaoming = new Person();
   对象的属性 xiaoming.name
   对象的方法 xiaoming.sleep()

6. 类
   静态的属性（属性）
   动态的行为（方法）

每一个牛逼人都有一段苦逼的时光，只要能像傻逼一样坚持下去，终会牛逼!