java面向对象-part01-创新互联

成都创新互联公司专业为企业提供永吉网站建设、永吉做网站、永吉网站设计、永吉网站制作等企业网站建设、网页设计与制作、永吉企业网站模板建站服务，10年永吉做网站经验，不只是建网站，更提供有价值的思路和整体网络服务。

方法

对方法的一些理解

设计方法的建议

方法的定义

面向对象和面向过程的区别

面向过程

面向对象

类和对象

类的构造器（类的构造函数）

修饰词：this

用于修饰属性

用于修饰方法

this用于修饰构造器

方法的重载

什么是方法的重载

方法重载的例子

第一个例子，重载是依靠不同的参数来区别而不是依靠不同类型的返回值来区别

第二个例子，参数个数不同情况下的重载

第三个例子，参数类型不同情况下的重载

第四个例子，参数位置不同情况下的重载

形参和实参

形参（形式参数）

实参（实际参数）

可变个数的形参（传递的参数个数是可变的）

基本格式

使用说明

举个栗子

权限修饰符（public、protected、default、private）

封装

封装的目的

封装的作用

一个封装例子

方法对方法的一些理解

方法是解决一类问题的步骤的有序结合
方法包含在类和对象之中
方法在一个类中被创建，在其他地方被调用

设计方法的建议

尽可能地使每一个方法实现一个功能，这样一来可以方便进行扩展

方法的定义

[访问修饰符] 方法的返回值类型 方法名([参数类型 参数名]){
    ...
    方法体
    ...

    [return 返回值;]
}

访问修饰符表明了该方法的访问类型，访问修饰符可以是public、private、protected、default中的任意一种。
访问修饰符可以不写，当没有写访问修饰符时，默认使用default作为访问修饰符。例如下面的代码使用的便是default访问修饰符。
```
public class class1{
    void fun1(){
        System.out.println("这是一个方法");
    }
}
```
方法的返回值类型表明该方法最后将数据以什么数据类型返回给该方法的调用者。
方法名用于标识一个方法，调用时通过方法名来选择所要调用的方法。
参数部分用于定义该方法传递的参数，一个方法可以有多个传递参数，也可以没有传递参数。
方法体：方法中需要执行操作的部分。
返回值：返回一个值给该方法的调用者。
需要注意的是，当返回值类型为void时，方法不需要也不可以拥有返回值。

面向对象和面向过程的区别面向过程

面向过程实现了一种解决问题的步骤
使用函数实现解决问题的步骤
在需要时通过函数调用来实现这些步骤，最终解决问题
面向过程的性能比较高
比较注重解决问题的过程

面向对象

面向对象将构成问题的事务分解成对象
建立对象是为了描述某一个事务在解决整个问题的过程中发生的行为
面向对象具有：封装性、继承性、多态性
对象容易维护、容易复用、容易扩展
通过面向对象的方式可以设计出具有低耦合性的系统

类和对象

在内容上，类是对象的一些属性以及对象的一些行为方法
在定义上，类是某一类事物的整体描述（或者是定义）
面向对象实际上就是以类的方式组织代码，以对象的方式组织（或者是封装）数据
对象就是类的具体化
类的抽象层级比较高，对象的抽象层级比较低
下面看一个简单的类和对象的关系：

//class1.java
public class class1{
    //以人类为例

    //定义一些属性
    private String country;//国家
    private String area;//地区
    private String city;//城市
    private String address;//住址
    private int age;//年龄
    private String sex;//性别
    private String name;//姓名
    private String phone;//电话

    //定义一些方法
    //告诉别人自己的国家
    public String getCountry() {
        return country;
    }

    //告诉别人自己的地区
    public String getArea() {
        return area;
    }
}

//class2.java
public class class2{
    public static void main(String[] args) {
        //创建一个对象（实例化一个类）
        class1 c1 = new class1();
        //输出
        System.out.println(c1.getCountry());
    }
}

类的构造器（类的构造函数）

在创建一个对象时，会调用该类的构造函数
在没有重写类的构造函数时，类默认地会有一个构造函数，也就是说，即使一个类中一片空白，也会隐式地有一个方法，这个方法就是类的构造函数。例如下面这个例子：

//class1.java
public class class1{
    
}

//class2.java
public class class2{
    public static void main(String[] args){
        class1 c1 = new class1();
        //类class1中，什么内容都没有，但是在此处创建class1的对象可以成功地创建，这就是调用了隐式存在的类的构造函数
    }
}

类的构造器有两个特点：①构造器的名称和类名是相同的；②类的构造器没有返回值。
类的构造器的作用：在使用new关键字创建对象时，实际上就是在调用类的构造器
默认地，类会有一个隐式的没有任何传递参数的构造器

如果定义了有传递参数的类的构造器，那么便需要一并将没有参数传递的类的构造器显示定义。例如：

//class1.java
public calss class1{
    int age;

    public class1(int i){
        this.age = i;
    }
    //上面定义了有参构造函数，此处便需要一并显式定义无参构造函数
    public class1(){
        this.age = 1;
    }
}

修饰词：this 用于修饰属性

在一个类中，如果要访问的内容是类中的属性，那么最好在属性前加上this修饰词。例如：
```
//this修饰属性时的用法
this.属性名 = 值或者是变量名;
```
为什么上面说“最好加上this修饰词”而不是“一定需要加上this修饰词”，因为并不是所有情况下不加this修饰词都会得到错误的结果

当没有发生重名时，即等式左边的属性名和等式右边的变量名不重名时，this修饰词可以省略不写，此时带有this修饰词和不带有this修饰词的效果相同。例如：

//class1.java
public class class1{
    int age;

    public void setAge(int num){
        age = num;
        this.age = num;
        //上面两种写法的效果相同，两种写法属性age都可以获得num的值
    }
}

但是发生重名时，即等式左边的属性名和等式右边的变量名重名时，this修饰词不可以省略，当this修饰词省略时，会获得预期之外的效果。例如：

//class1.java
public class class1{
    int age;

    public void setName1(int age){
        age = age;
        //当发生重名并且不使用this修饰符的情况下，属性的赋值会遵守“就近原则”
        //也就是说，此处等式左边的age获得的值，并不是setName1函数中传递进来的参数age的值，而是这一个类中属性age的值，因此执行完这一句后，属性age的值为0（相当于把自己赋值给自己，什么都不会被改变）
    }

    public void setName2(int age){
        this.age = age;
        //执行完这一句后，属性age的值为setName2函数中传递进来的参数age的值
    }
}

用于修饰方法

在同一个类中，方法和方法之间可以互相调用

在这种情况下，调用时，方法名前面的this可以有也可以没有，不会影响最终的效果。例如：

//class1.java
public class class1{
    //计算两数的和
    public int add(int a,int b){
        return a + b;
    }
    //计算一组数字的和
    public int addArr(int[] nums){
        int sum = 0;
        for(int i:nums){
            sum = add(sum,i);//此处无论写不写this，调用的都是类class1下的add()方法，因此在方法调用时，this是可以省略的
        }
        
        return sum;
    }
}

this用于修饰构造器

在同一个类中，构造器之间可以互相调用
构造器调用构造器时，需要用this修饰符对调用的构造器进行修饰
调用构造器时，调用语句需要放在构造器的第一行
调用方法为：this(需要传递的参数)

下面是一个构造器调用构造器的例子：

//class1.java
public class class1 {
    int age;
    String name;

    //该类的无参构造器
    public class1() {
        //调用了一个该类的有参构造器
        this("张三");
        age = 10;
    }

    public class1(String name) {
        this.name = name;
    }
}

但是需要注意的是，在构造器中可以调用该类的方法，但是在方法中不能调用该类的构造器

方法的重载什么是方法的重载

在一个类中，允许存在多个同名方法，但是这些同名方法的传递参数是不同的
传递参数不同可以有这些情况：①参数的个数不同；②参数的类型不同；③参数的位置不同（这一种情况并不是在所有场合下都通用的）

方法重载的例子第一个例子，重载是依靠不同的参数来区别而不是依靠不同类型的返回值来区别

//class1.java
public calss class1{
    //有如下两个同名方法，它们的参数相同但是方法的返回值不同
    public int add(int a,int b){}
    public double add(int a,int b){}
    //如果将上面的代码复制到IDE中，则编译器会报错，因为方法的返回值并不作为方法重载的依据
}

第二个例子，参数个数不同情况下的重载

//class1.java
public class class1{
    //有以下两个函数，这两个函数是重载的，它们的参数个数不同
    public int add(int a,int b){}
    public int add(int a,int b,int c){}
}

第三个例子，参数类型不同情况下的重载

//class1.java
public class class1{
    //下面几种方法都是重载的，它们的参数类型不同
    public double add(int a,int b){}
    public double add(int a,double b){}
    public double add(double a,int b){}
    public double add(double a,double b){}
}

第四个例子，参数位置不同情况下的重载

//class1.java
public class class1{
    //参数位置不同情况下的重载
    //这种情况需要特别注意，因为不是简单粗暴地交换参数的位置就是重载了

    //先来看下面几种是重载的情况
    public void show(int a,int b,String c){}
    public void show(int a,String c,int b){}
    public void show(String c,int a,int b){}
    //这几种写法是可以成功重载的，简单地说，它们也是属于参数类型不同的情况

    //将上面三个重载函数保留，那么下面这些写法便不是重载，并且编译器会报错
    public void show(int b,int a,String c){}
    public void show(String c,int b,int a){}

    //上面两个函数不能构成重载，简单地说，它们的参数类型和已经存在的同名函数的参数类型相同
    
    //因此严格地说来，只有两种情况构成函数的重载
    //1.参数的个数不同
    //2.参数的位置不同

    //用另一种方法分析，可能更容易看出上面函数不能重载的原因
    //从函数的声明来看，上面的函数声明依次是这样的
    public void show(int,int,String);
    public void show(int,String,int);
    public void show(String,int,int);

    public void show(int,int,String);
    public void show(String,int,int);
    //这样便很容易可以发现，有几个函数在声明时的参数类型顺序是重复的，折旧造成这些参数类型顺序重复的函数无法构成重载
}

形参和实参形参（形式参数）

在定义函数名和函数体的时候使用的参数
形参的目的是用来接收调用该函数时传入的参数

实参（实际参数）

在调用有参函数时，主函数和被调函数之间存在的数据传输
实参才是调用有参函数时真正传递的内容

下面是一个例子：

//class1.java
public class class1{
    public static void main(String[] args){
        show("111");//这边传递的参数便是实参
    }
    
    public static void show(String str){//这边的str便是形参
        System.out.println(str);
    }
}

可变个数的形参（传递的参数个数是可变的）基本格式

数据类型...变量名

使用说明

可变个数的形参的声明只能放在形参部分的末尾
一个函数的形参声明部分只能有一个可变个数的形参

举个栗子

//class1.java
public class class1 {
    public static void main(String[] args) {
        show(1, "12", "34", "56");
    }


    public static void show(int i, String... str) {
        for (String s : str) {
            System.out.println(s);
        }
    }
}

权限修饰符（public、protected、default、private）

权限修饰符所提供的访问权限
权限修饰符	在类内部的访问权限	在同一个包中的访问权限	在不同的包中的访问权限	在同一个项目中的访问权限
private	可以被访问	不可以被访问	不可以被访问	不可以被访问
default	可以被访问	可以被访问	不可以被访问	不可以被访问
protected	可以被访问	可以被访问	可以被访问	不可以被访问
public	可以被访问	可以被访问	可以被访问	可以被访问

封装封装的目的

封装应该将类中的一些内容隐藏掉，只允许在类内部被直接访问，而在类外部只能通过方法调用的方式被访问

封装的作用

提高程序的安全性，保护数据
隐藏代码的实现细节
统一接口
增加系统的可维护性

一个封装例子

//class1.java
public class class1 {
    private int age;

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

//class2.java
public class class2 {
    public static void main(String[] args) {
        class1 c1 = new class1();
        c1.setAge(20);
        System.out.println(c1.getAge());
        //若是通过c1.age直接访问类的成员变量，编译器便会报错，因为成员变量age是private类型，无法直接被外部访问
    }
}

你是否还在寻找稳定的海外服务器提供商？创新互联www.cdcxhl.cn海外机房具备T级流量清洗系统配攻击溯源，准确流量调度确保服务器高可用性，企业级服务器适合批量采购，新人活动首月15元起，快前往官网查看详情吧

分享标题：java面向对象-part01-创新互联
网页链接：http://azwzsj.com/article/deopjs.html

java面向对象-part01-创新互联

其他资讯