Java基础---面向对象---类与方法

1，面向过程与面向对象

面向过程：

优点：

代码直观，相对容易看出代码走向，我们是根据功能去直接开发，

自上而下

缺点：

代码的维护与扩展，再次利用比较困难

面向对象

优点：

代码易维护，相对易扩展，代码可复用率高

缺点：

代码的封装，与面向过程比较会稍微难看出一点走势

2，什么是面向对象

比如，我们希望在一个游戏中炸毁一颗星球

面向过程：

我们会考虑游戏中那颗星球的的一些引爆因素，那个星球的一些环境问题

主要围绕这颗星球进行

面向对象：

我们会考虑所有星球他存在的一些引爆因素，所有星球的一些环境问题

主要围绕星球整体

所以说:

面向过程，我们只会实现当前目标，如果把“这颗星球”替换成“那颗星球”此时我们需要重新操作

面向对象：我们只需要实现这一整套逻辑，无论是这颗星球还是那颗星球都可以当作参数去调用对应方法

3，面向对象

核心：类

两大核心

静态特征：属性，成员变量

4，类和对象

对象是类的实例

 理论来说，如果不做特别的约定，那么一个类可以实例化多个对象

5，声明一个类

Dog.java

public class Dog{
    //属性
    //狗名
    String dogName;
    //品种名
    String typeNaeme;
    //狗性别
    char dogSex;
}

Test.java

public static void main(String[] args){
		//实例化四只狗
    	Dog dog = new Dog();
    	Dog wangCai = new Dog();
    	Dog laiFu = new Dog();
    	Dog daHuang = new Dog();
    
    	//给地一只狗补充他的全部属性
    	dog.dogName="狗";
    	dog.dogSex="1";
    	dog.typeNaem="中华田园犬";
    	//给第二只狗补充它的属性
    	wangCai.dogName="旺财";
    	wangCai.typeName="柴犬";
    	//给第三只狗补充他的一个属性
    	laiFu.dogName="来福";
    	//不给第四只狗补充属性
    
    	//打印狗的名字
    	System.out.println(dog.dogName);
}

6，声明一个方法

//方法由
//访问修饰符【public/static/final】 返回类型【void无返回类型 引用数据类型-string/自定义类,基本数据类型-八大基本数据类型，方法名(参数) {方法体} 】

例如

public class Dog{
    //属性
   	//····
    
    //方法
    //犬吠
    //public为修饰符（访问修饰符）
    //void为返回类型（void是无返回类型）
    //返回类型如果是void，可以没有return（但是你也能写return，return的作用为结束当前的方法）
    //return和break不一样，break的作用在switch和循环中，是打破的意思，return是返回的意思
    //barking方法名--符合标识符命名规则，规则和变量基本相同，首字母要求小写，并且满足驼峰命名，
    //有意义
    //（）内的为参数，这个方法是无参方法（没有参数的方法）
    //{}花括号为方法体，这个方法是输出一句话
    public void barking(){
        System.out.println("这只名叫"+dogName+"的狗发出了声音···");
        
        //将这个狗变成字符串，展示出它的属性
        //如果你的返回类型不为void，那么你这个方法一定要return，并且return的这个内容必须符合你的返回类型
        public String toString(){
            return "{dagName="+dogName+"typeName="+typeName+"dogSex="+(int)dogSex+"}";
        }
        //此方法会返回够的名字
        
        //dogName为这个类的一个属性，属性的类型为String和这个方法的返回类型一致
        public String getName(){
            return dogName;
        }
}
}

//方法的使用，两种情况
//同一个类中，可以直接调用，比如：
//print()调用show()方法不需要实例化Zoo对象

//不同类中调用一般方法，先实例化Zoo对象获得zoo之后使用zoo.print();进行调用

7，方法的参数：

1，1形参和实参

      

定义方法时：形式参数（形参）=》定义了方法参数的类型

调用方法时：实际参数（实参）=》值

1，2方法的参数

 

参数的类型可以是基本数据类型（八大基本数据类型）

也可以是引用数据类型（如String.Dog(自定义类)

1，3构造一个带有参数的方法

//构造
<访问修饰符>  返回类型 <方法名> （参数类型 参数1，参数类型 参数2，参数类型 参数3）{
			//方法的主体
}

//调用
对象名，方法名（参数1，参数2，参数3）

1，4多个参数的实例

//方法：
  public int ChaRu(String []stuservice,String name){

        for (int i = 0; i < stuservice.length ; i++) {
            if(stuservice[i]==null){
                stuservice[i]=name;
                System.out.println("插入成功");
                return 1;
            }
        }
        System.out.println("数组已满，插入失败");
        return -1;
    }

    public int ChaXun(String []stuservice,String name,int start,int end){

        for (int i = start; i <=end ; i++) {
            if(name.equals(stuservice[i])){

                System.out.println("查询成功，姓名下标为" + i);
                return i;

            }
        }
        System.out.println("查询失败");
        return -1;


    }

//调用
 public static void main(String[] args) {
        Scanner input =new Scanner(System.in);
        String [] stuservice = new String[5];
        Zuoye01 stu = new Zuoye01();

        stuservice[0]="张三";
        stuservice[1]="李四";
        stuservice[2]="王五";

        System.out.println("按1进入插入功能");
        System.out.println("按2进入查询功能");


        while(true){
            System.out.println("请选择你要进入的功能");
            int flag = input.nextInt();
            if(flag==1){
                System.out.println("你已进入插入功能");
                System.out.println("请输入你要插入的姓名：");
                String name = input.next();
                 stu.ChaRu(stuservice,name);

            }
            if(flag==2){
                System.out.println("你已进入查询功能");
                System.out.println("请输入你要查询的姓名：");
                String name = input.next();;
                System.out.println("请输入起点：");
                int start = input.nextInt();
                System.out.println("请输入终点");
                int end = input.nextInt();

                  stu.ChaXun(stuservice,name,start,end);

            }
        }
   }

1，5不同参数类型在传递时的区别

基本数据类型传递只是单纯把值传递过去，在方法中，调用会调用值的变化，可是对于原本调用方的基本数据类型变量不会发生变化

引用数据类型（String除外，String非常特殊，在作为参数的情况下，情况等同于基本数据类型，但是一定要记住，String不是基本数据类型，他是一个引用数据类型，只不过他很特殊），在传递的情况下，是传递内存地址，由于传递了内存地址，所以你在方法体中进行数据修改，那么原本调用方的内存地址指向的结果跟着改变，从而导致会自动修改引用数据类型的值。

//方法：
package com.kgc.day10;

public class Test {
    public void calc1(int num){
        num+=1;
    }
    public void calc2(Student stu){
        stu.age+=1;
    }
    public void calc3(String str){
        str+="2";
    }
}

//调用
package com.kgc.day10;

public class Test02 {
    public static void main(String[] args){
        Test test = new Test();
        int n=8;
        test.calc1(n);
        Student stu = new Student();
        stu.age = 18;
        test.calc2(stu);
        String str = "1";
        test.calc3(str);
        System.out.println(n+"---"+stu.age+"---"+str);
        //结果为8----19----1
    }
}

cal2方法传递的是一个对象的引用类型

package com.kgc.day10;

public class Student {
    int age;
}

8，构造方法

public class Cat{
    String catName;
    
    public Cat(){
        System.our.println("你进入了Cat（）的无参构造器（无参数构造方法）");
    }
    
    public Cat(String catName){
        System.out.println("你进入了Cat（String catName）的有参构造器（有参构造方法）");
        this.catName = catName;
        System.out.println("你将参数catName（“+catName+”）赋值给这个对象的catName这个属性");
    }
}

public static void main(String [] args){
    Cat cat = new Cat();
    Cat cat1 = new Cat("哆啦B梦");
    System.out.println(cat1.catName);
}

this关键字，this这个，指的是在一个类中用于声明这个标识符是标识的当前对象的属性，例如

public Cat(String catName){
    //这个this就代表，将参数catName赋值给当前对象（谁调用这个方法，谁就是当前对象）的对应属性
    this.catName = catName;
}

//有参构造器可以同时存在多个
//参数构造期可以同时存在多个参数
//有参构造器可以和无参构造器同时存在，只不过当你写了有参构造器，那么系统就不会自动生成无参构造器
public Cat(String catName,int catAge,char catSex){
    this.catName = catName;
    this.catAge = catAge;
    this,catSex = catSex;
}

this可以调用属性

System.out.println(this.catName);

this可以调用方法

this.catchMouse(mouse);

this可以调用构造方法

this();
this("Tom");

关于无参构造器

当你一个类写完没有写任何构造器的时候自动生成的一个构造器，如果当你这个构造器存在了任意（有参或无参）你新增的构造器，那么，系统自动生成的无参构造器将不会存在

所以，当你一个类如果存在了有参构造，你仍然在某些地方会用到他的无参构造器，那么你就需要将无参构造器手动重写，否则，将无法调用这个无参构造方法

例如：

 

此时发现其余地方

他的无参构造方法均报错了

9，方法重载

//同一个类中

//方法名相同

//参数个数或类型不同

//与返回值，返回修饰符无关

比如System.out.println()这个方法就是一个多次重载的方法，具体可以查看该代码源码

 

满足同一个类

方法名相同

参数个数不同

说明是println方法的重载

10，成员变量

局部变量的作用域仅限于定义它的方法

成员变量的作用域在整个类内部都是可见的

初始值不同

java会给成员变量一个初始值

java不会给局部变量赋予初始值

在同一个类中，成员变量和局部变量同名时，局部变量具有更高的优先级