java小白从入门到精通（基础四）

八:Java中的面向对象的编程

1.面向对象编程和面向过程编程
java：面向对象编程的语言 C：面向过程的语言
面向对象编程：注重的是问题的拆解 面向过程编程：注重于解决问题的过程

• java是纯面向对象的编程语言
• python php javascript是半面向对象编程语言
• 面向对象的编程语言是通过把大问题抽象成一个一个的小问题,通过解决一个一个的小问题,来解决大问题
• 面向对象编程是通过调用对象的方法来完成功能

2.生活中的面向对象
对象：现实生活中客观存在的实体都是对象。（世界万物皆对象）
生活中的对象都有属性（静态）+行为（动态）

3 编程中的对象
编程：变成就是为了使得人类的生活变得更加快捷（造福人类），其实编程就是解决人在生活中遇到的各种问题。所以说
生活中的对象就是编程中的对象。
对象：其实对象就是拥有属性和行为的一个具体的实例。

九：类和对象

    对象：其实对象就是拥有属性和行为的一个具体的实例。
    类：对象的一个抽象的“集合”，类就是对象的模板

1.类的定义
对象有属性和行为(函数(function)|方法(method))
属性=>成员变量
方法=>成员方法
属性+方法 => 成员

//类名必须符合大驼峰命名法
class 类名{
    类体
}

class Person{
     
    //定义对象的属性
    String name;  //姓名
    String sex; //性别
    int age; //年龄
//定义类的行为（方法   函数）
    void main(){
     
       System.out.println("say hello");
    }
}

2.对象的实例化
类：其实好像就是对象的模板；
对象：其实就是根据模板来进行对象的实例化；
实例化对象：根据类中定义的属性和行为实例化出来一个具体的对象，实例化的对象就拥有这些属性和行为。

public class Demo01{
     
    piblic static void main(String[] args){
     
        Person p = new Person();  //实例化对象
        //使用对象来访问对象的属性
        System.out.println(p.name);
        //对象的属性赋值
        P.name = ""小花;
        p.age = 20;
        System.out.println(p.name);
    }
}

对象的创建过程
创建一个子类对象时,首先会创建父类的对象,然后再创建子类的对象,然后再把父类的对象和子类的对象绑定在一起,返回一个新的子类的对象;

-创建对象的细节

• 使用new关键字来创建类的对象
• 对象的类型是,类
• 在同一个类中不能出现相同名称的属性,不能出现相同定义的方法

//使用类来创建对象
Person p1 = new Person();//创建了一个Person类(型)的对象
Person p2 = new Person();//创建了一个Person类(型)的对象
Person p3 = new Person();//创建了一个Person类(型)的对象

3.对象属性的访问

public class Demo01{
     
    piblic static void main(String[] args){
     
        Person p = new Person();  //实例化对象
        //使用对象来访问对象的属性
        System.out.println(p.name);
        //对象的属性赋值
        P.name = ""小花;
        p.age = 20;
        System.out.println(p.name);
        //调用对象的方法
        p.say();
    }
}

/**
*类的定义
*/

class Person{
     
    //定义对象的属性(成员变量)
    String name;  //姓名
    String sex; //性别
    int age; //年龄
    
    //定义类的行为（方法   函数）
    void main(){
     
        System.out.println("say.....");
    }
}

4.类的成员
类的成员 = 成员变量（属性）+成员方法（方法） 属性：固定不变的东西（年龄 身高 性别）
方法：实现功能的（吃 喝 玩 跑）

package com.uplooking.demo01;
public class Person{
     
    String name;  //成员变量可以不给定初始值，成员变量是有默认值的
    int age;
}

成员变量的默认值
-基本类型：对应基本类型的默认值
-引用类型：：默认值为null。

5.成员方法
什么是方法：将代码提取出来放在一个{}中，给这段代码起名，在需要时，通过名字调用即可-------即程序中定义的方法。
就是将完成特定功能的代码块进行的封装，类似于C语言中的函数。 在面向对象编程中把函数是称为方法
方法的定义格式
[访问修饰符] 返回值类型 方法名称（参数类型 参数名1，参数类型 参数名2，。。。）{
方法体
return 返回值;
}
ps:返回值类型如果为void则代表没有返回值；方法名称使用小驼峰命名法；参数列表，可以是任意
参数，多个参数之间使用逗号分隔；方法体：执行的代码，如果有返回值，则必须使用return关键字。

package com.uplooking.demo01;    
int say(){
        //修饰符可有可没有
System.out.println("hello uplooking...");
return 10; //返回到调用方法say
}

void sum(String a, int b){
        //a，b为形参
    //String类型与基本类型的数据进行拼接时，会先把基本类型的变量转换为String类型的变量，再进行计算
    System.out.println(a + b);
}

修饰符：现在使用固定的 public static
返回值类型：就是方法执行完成后的结果的数据类型
方法名：就是一个名字，要求符合命名规则。
参数：
a.形式参数：就是方法中（）里面写的，用来接收实参。
b.实际参数：就是实际参与运算的。
参数类型：数据类型
参数名：就是变量名
函数体：就是完成特定功能的代码
return：结束方法
返回值：就是方法的最后结果，由return待会给调用者。
方法的定义
方法的定义是由返回值类型 方法名称 参数列表三部分组成

返回值类型 方法名称(参数列表){
    方法体
}

/******      要定义一个方法前，先必须明确2个东西： 返回值类型，参数列表 （要几个类型，每个参数的数据类型是什么）    ******/
//没有返回值 没有参数列表的方法
void say() {
    System.out.println("say hello");
}

//有返回值,没有参数列表的方法
int say1() {
    return 1;
}

//有返回值,有参数列表的方法
int sum(int a, int b) {
    int s = a + b;
    return s;
}

方法的特点：不调用不执行；通过方法名在main方法中调用

-成员变量

• 成员变量就是属性

• 成员变量可以是基本类型,也可以是引用类型

• 成员变量可以不用初始化,不初始化其实是有默认值的,基本类型的默认值对应基本类型的默认值,引用类型的默认值是null

• 成员变量一般不用手动初始化

• 每个对象都拥有自己的成员变量和成员方法

6.方法的重载（OverLoad）
----方法的功能相同，参数列表不同。为了让见名知意，java允许他们的名字一样。这种情况有一个专业的叫法：方法重载
在同一个类中的两个方法满足以下条件，则构成的关系成为重载关系：方法名称相同、参数列表不同（个数不同、类型不同）
在调用的时候，虚拟机会通过参数的不同来自动区分同名的方法
特点：******和返回值类型无关，只看方法名和参数列表

7.方法的调用
对象.方法名称(实参列表);

package com.uplooking.demo01; public class Main{
     
    public static void main(String[] args){
     
        Person p = new Person();  //实例化对象
        int result = p.say();  //方法的调用
        System.out.println(result);
        p.sum("10",20);  //传递的10，20为实参
        p.sum("10");  //参数个数不匹配错误
        p.sum("10","20");  //参数类型不匹配错误
        p.sum(10,"20");  //参数类型不匹配
    }
 }

public class Main{
     
public static void main(String[] args){
     
       //程序的入口
       Person p = new Person();
       p.name = "小明";
       p.age = 20;
       System.out.println("name:" + p.name);   //小明
       Person p2 = new Person();
       p2.name = "小胖";
       //static修饰的成员不建议使用对象来直接调用，可以使用类来进行调用
       System.out.println("p2的name:" + p.name);   //小胖
       System.out.println("p2的name:" + p2.name);  //小胖
   } 
}

package com.uplooking.demo02;
public class Person{
     
    //成员变量
    static String name;
    int age;
    //成员方法
    void say(){
     
        System.out.println("hello uplooking...say");
    }
    static void say1(){
     
        System.out.println("hello uplooking...say1");
    }
}

方法区中的数据是所有对象共享的，普通对象的属性是在堆里面，而static修饰的成员都在方法区中存储。
单独调用（使用方法名直接调用），没意义。 直接输出语句调用，但是不好。 赋值调用，推荐使用。

练习：
//定义一个求两个整数之和的方法

class Demo{
     
    public static void main(String[] args){
        // 1.程序从main进来
        int a = 4;
        int b = 8;    // 2.定义2个int类型变量
        int i = sum(a,b);    // 3.通过方法名调用方法并传入参数
        System.out.println(i);  //6.输出结果
    }
        /*
        确定2个东西：
        返回值类型：整数  int
        参数列表：2个，int a     int b
        */  
   public static int sum(int a,int b){
        // 4.把main中的a， b传过来传给了sum方法 4，5
   return a+b;   // 5.先计算a+b的值 = 12，然后通过return把12返回给了调用者。
   } 
}

练习：
定义一个方法，使用键盘输入2个值，比较返回最大值（至少写出两种写法）
定义一个方法，使用键盘输入2个值，比较返回是否相等（至少写出两种写法），参数分别使用2个byte，两个short，2个int，2个long，在main方法中测试。
定义一个方法，使用键盘输入3个值，比较返回最大值（至少写出两种写法）

方法的注意事项：
方法无调用不执行、方法和方法是平级关系，不能嵌套、方法定义时，参数之间用逗号隔开、方法在调用时不需要在传递数据类型、如果方法有明确返回值必须要有return带会一个值。
//在控制台输出n行n列* 需求不断改变，代码相同，只需改变i和j的值就可以了
//所以我觉得使用方法改进

class Demo{
     
    public static void main(String[] args){
     
        
    /*
    返回值类型：没有具体的返回值，但是我们定义方法的格式中必须有东西，所以这里使用void。
    参数列表：int a, int b
    */
    public void printStar(int a,int b){
     
        for(int i=0;i<a;i++){
     
            for(int j=0;j<b;j++){
     
              System.out.print("*");  
            }
            System.out.println();
        }
    }
}

//求n个数求和

public class Demo{
     
    public static void main(String[] args){
     
    }
    public static int sum(int a,int b)
    return a+b;
}

6.Java中的static关键字
static可以修饰静态方法(成员方法)、静态属性(成员变量)，static修饰的成员属于所有对象共享的。
static修饰的成员，sun公司不建议使用对象来进行调用。因为static修饰的成员是类级别的，所以直接使用类来进行调用。

package com.uplooking.demo03;
public class Person{
     
    //成员变量
    static String name;
    int age;
    
    //成员方法
    void say(){
     
        System.out.println("hello uplooking...say");
    }
    static void say1(){
     
        System.out.println("hello uplooking...say1");
    }
}

public clss Main{
     
    public static void main(String[] args){
     
        Person.name = "小胖";
        Person.p1 = new Person();
        Person.p2 = new Person();
        
        System.out.println("p1的name:" + p1.name);  //小胖
        p1.name = ""小花;
        Person.name = "小胖"；
        System.out.println("p2的name:" + p2.name);  //小胖
    }
}

return关键字

• return关键字只能出现在方法中
• return关键字的含义就是结束正在执行的方法,返回方法调用的地方

this关键字

this指调用当前方法的对象

7.Java中的构造方法

• 构造方法不需要我们自己调用

• 构造方法,当我们new对象的时候,底层帮我们调用

• 构造方法没有返回值,没有返回值和返回值为空(void)是两个概念;

• 构造方法的名称(也是返回值类型)和类名相同

• 如果我们不写任何的构造方法,系统会帮我们生成无参数的构造方法

• 如果我们编写了构造方法(不管有参无参),系统都不会帮我们生成了

• 构造方法一般是用来初始化成员变量

• 构造方法是创建对象时调用的方法，是用来进行对象初始化操作，他就是我们一个对象产生的时候的一个方法，通过这个方法就可以产生一个对象
  构造方法的定义
  [访问修饰符]类名(形参列表){
  构造体()
  }

package com.uplooking.demo06;
public class Main{
     
    public static void main(String[] args){
     
        //实例化对象
        Person p1 = new Person("小花",20);
        System.out.println(p1.name);
        System.out.println(p1.age);
        
        Person p2 = new Person();  //无参
    }
}


package com.uplooking.demo06;
public class Person{
     
    String name;
    int age;
    //java中如果不手动的声明构造方法，系统会帮我们创建一个无参数的构造方法
    Person(){
     
     System.out.println("构造方法。。。。");   
    }
    //有参
    Person(String name, int age){
     
        this name = name;
        this age = age;
    }
}

eg:
//Java中如果我们不显示的声明构造方法，系统会帮我们生成一个无参数的默认的构造方法

Person(){
     
    Dog dog = new Dog();
}

如果我们声明的构造方法，系统则不会帮我们生成了
有参数的构造方法

Person(String name, int age){
     
        this name = name;
        this age = age;
        Dog dog = new Dog("二哈",2,"公");
    }
}

在商业项目中一般会利用有参数的构造方法给成员变量赋值。
如果我们写了有参数的构造方法，一般我们也会写一个无参数的构造方法，方便使用。

8.利用idea来生成构造方法

public class Person{
     
    String name;
    int age;
    String sex;
    String phone;
    String addr;
    String number;
    Person(String name,String sex){
     
         this.name = name;
        this.sex = sex;
    }
    
    Person(String name,int age,String sex){
     
        this.name = name;
        this.age = age;
        this.sex = sex;
    }
}