Java类与对象 详解

面向对象简述：

面向对象是一种现在最为流行的程序设计方法，几乎现在的所有应用都以面向对象为主了，最早的面向对象的概念实际上是由IBM提出的，在70年代的Smaltalk语言之中进行了应用，后来根据面向对象的设计思路，才形成C++，而由C++产生了Java这门面向对象的编程语言。

但是在面向对象设计之前，广泛采用的是面向过程，面向过程只是针对于自己来解决问题。面向过程的操作是以程序的基本功能实现为主，实现之后就完成了，也不考虑修改的可能性，面向对象，更多的是要进行子模块化的设计，每一个模块都需要单独存在，并且可以被重复利用，所以，面向对象的开发更像是一个具备标准的开发模式。
 

面向对象的基本特征：

（1）封装：保护内部的操作不被破坏；
（2）继承：在原本的基础之上继续进行扩充；
（3）多态：在一个指定的范围之内进行概念的转换。

通过对象名使用成员变量，最基本都方法是：

对象名.成员变量名

认识类和对象：

定义一个类的语法：

class 类名{

                所含变量定义； //类的名字只能是java中的关键字

}

例如，定义一个Person类：

class Person {     // 类名称首字母大写
    String name ;
    int age ;
    public void tell() {        
          System.out.println("姓名：" + name + "，年龄：" + age) ;
         }
}

认识成员函数：

Java中的函数，编写在类中，一般称为成员函数，最简单的成员函数格式如下：

void  函数名称(){

                 参数内容；

}

调用这个成员函数的格式为：“对象名.函数名();”

带参数的成员函数的格式如下：

void 函数名称 (类型1 参数名1,类型2 参数名2,……,类型n 参数名n){

                函数内容;

}

调用方法为：“对象名.函数名(参数值例表);”

带返回类型的成员函数

格式如下：

void 函数名称 (类型1 参数名1,类型2 参数名2,……,类型n 参数名n){

                函数内容;

                return 和返回函数类型一致的某个变量或者对象;     

}

函数的参数传递：

1)简单数据类型，采用值传递

2)引用数据类型，采用引用传递

认识函数重载：

在Java中，不能盲目将函数名定义一样。必须满足以下体条件之一：

1)函数参数个数不同

2)函数参数个数相同，类型不同

3)函数参数个数相同，类型相同，但是在参数列表中的出现顺序不同

        如何定义和使用构造函数：

构造函数也是一种函数，但是定义时必须遵循以下准则：

1)函数名称与类的名称相同

2)不含返回类型

定义了构造函数之后，在实例化对象时，就必须传入相应的参数列表，否则报错。使用方法是：

类名 对象名=new 类名(传给构造函数的参数列表);

无参构造例子：

class Telphone:

public Telphone() {

        System.out.println("Telphone构造方法执行了");

}

注意：

1)当一个类的对象被创建时，构造函数就会被自己调用，可以在这个函数中加入初始化工作的代码。在对象的生命周期中，构造函数只会被调用一次。

2)构造函数可以被重载，也就是说在一个类中可以定义多个构造函数。在实例化对象时，系统根据参数的不同调用不同的构造函数

3)在一个类中如果没有定义构造函数，系统会自动为这个类产生一个默认的构造函数，该函数没有参数，也不做任何事情。因此，只有在没有定义构造函数时才可以通过:

类名   对象名 = new   类名() ;

如果用户自己定义了含有参数的构造函数，系统将不提供默认的构造函数。

使用对象操作类例子：

class Person { 
    String name ;
    int age ;
    public void get() {
        System.out.println("姓名：" + name + "，年龄：" + age);
    }
}

public class TestDemo {
        public static void main(String args[]) {
            Person per = new Person() ;// 声明并实例化对象
            per.name = "张三" ;//操作属性内容
            per.age = 30 ;//操作属性内容
            per.get() ;//调用类中的get()方法
        }
}

静态变量：

各个对象共有的内容只用一个空间保存，只需要将共有的变量定义成静态变量，方法实在其定义前加上“static”关键字即可。

静态变量的常见应用：

1)保存跨对象信息

2)存储对象个数

认识静态函数

静态变量和静态函数统称为静态成员。静态函数可以通过“类名.函数名”来访问，也可通过”对象名.函数名“访问。

静态代码块

当类被载入时，静态代码块被执行，且只被执行一次，静态块经常用来进行类属性的初始化。格式为：

static{

                需要静态执行的代码；

}

this

this修饰的变量用于指代成员变量

（方法的形参与成员变量同名，不带this修饰的变量指的是形参，而不是成员变量）

用于解决局部变量隐藏成员变量。

public class student{
    private int age;
    
    public void setAge(int age){
        this.age = age;//this使其指向了成员变量
    }
}

使用封装

封装是面向的基本特征之一。

如何实现封装：

1)将不能暴露的成员隐藏起来，不能让其在类的外部被直接赋值。将成员定义为私有，在成员定义前加上private

2)用公共方法来暴露对该隐藏成员的访问，可以给函数加上public，将该方法定义为公共

在Java中，使用类似的方法管理类，这就是包（packgae）

如何访问包中的类：

1)在同一个包中，直接用类名来访问，不用指定类所在的包：可以直接访问，不会报错。

2）两个类不在同一个包中：

        在使用类时，指定类的路径；

        用import语句导入该类。 

package机制：

通常是类的第一句非注释语句，通常在类的声明上方加“package 包名“写项目时最好加包，尽量不用默认包。

包名：域名倒着写即可，再加上模块名便于内部管理类。

在同一个类中直接用类名即可访问该类，否则需要指定包名。

import导入类：

功能：在本类中导入其它包的类

要点：1)java会默认导入Java.lang包下的所有的类

           2)如果同时导入不同包但名字相同的两个类，只能用包名+类名来显示调用相关类

              静态导入static import->导入指定类的静态属性方法

类的访问控制：

public：不写的情况下，属于默认访问修饰，此时，该类只能被同一个包中的所有类识别。写了的话，该类是一个公共类，可以被包内包外所有类识别。

对于成员来说，访问控制修饰符共有4个，分别是private、default、protected、public。特性如下：

1)private类型成员，只能在定义它的类的内部访问。

2)default类型成员，可以在定义它的类的内部访问，也可以被这个包中其他类访问。

3)protected类型成员，可以在定义它的类的内部被访问，也可以被这个包中的其它类访问，还可以被包外的子类访问。

4)public类型成员，可以在定义它的类的内部被访问，也可以被包内外的所有其它类访问。

注意：

1)静态变量可以通过”对象名.变量名“访问，而非静态变量不能这样使用。

2)如果一个包中的类很多，可以用”import包含.*“导入该包中的所有类。

3)内部类中的成员只在内部类范围才能使用，外部类不能像使用自己的成员变量一样使用它们。

4)如果在内部类中使用this，仅代表内部类的对象，因此也只能引用内部类的成员。

访问权限作用范围图：

	同一个类	同一个包	不同包的子类	不同包的非子类
private	✓
默认的	✓	✓
protected	✓	✓	✓
public	✓	✓	✓	✓

继承

在Java中，被继承的类叫做父类、基类或者超类，与之对应的叫做子类或者派生类。继承是通过extends关键字实现的，格式如下：

class 子类 extends 父类{

}

子类继承父类后，实例化子类对象时，系统会首先实例化父类对象。

实例：

//父类
public class file{
    public long size;     //文件大小
    public String name;    //文件名
    public void info()    //显示文件信息
    {
        System.out.println(name + " " + size);
    }
}
//子类
public class videofile extends file()
{
    //父类的public成员自动继承
    //private不能被继承，子类无权访问    
    //只需要添加子类的特性
    public int duration //时长    
    public void play()
    {
       System.out.println("播放" + this.name);
    }
    public void stop()
    {
        System.out.println("停止" + this.name);
    }

成员的覆盖：

若父类没有不带参数的构造函数，有两种方法：

1)给父类增加一个不带参数的空构造函数。

2)在子类的构造函数中，第一句用super来给父类构造函数传参数。

子类中成员函数的定义和父类相同，指名称相同、参数列表相同、返回类型相同。如果子类中的函数定义和父类相同，最后调用时时调用子类中的方法。这叫做覆盖或者重写（Override）。

多态性

多态，也是面向对象的基本特征之一，也是软件工程的重要思想。动态多态的理论基础时：父类可以指向子类对象。

”父类引用可以指向子类对象“可以延申到如下两个方面：

1)函数传入的形参可以是父类类型：

根据多态性原理，子类对象无需砖换，就可以赋值给父类引用

2)父类类型对象转换成子类类型：

严格讲，父类类型对象无法转换成子类类型。但是又一种特殊情况，如果父类类型对象原来就是某一种子类类型的对象，就可以转换成相应子类类型对象，此时使用强制类型转换即可。

抽象类和接口：

含有抽象函数的类叫做抽象类，抽象类必须用abstract修饰。抽象类还可以含有普通成员函数，如果一个抽象类中的所有函数都是抽象的，我们也可以定义为接口。

在”继承接口“的情况下，一般有另一种说法，叫做”实现接口“，子类也叫做实现类。

注意：

1)子类中通过implements来实现接口中的规范

2)接口不能实例，但可用于声明引用变量类型

3)一个类实现了接口，必须实现接口中所有抽象方法，且这些方法只能是public

4)接口客多继承

5)格式：class 子类 extends 父类 implements 接口1，接口2，……{}

其它内容：

final：

1)用final来修饰一个类，表示该类不能被继承

2)用final来修饰一个函数，该类在被子类继承的情况下，此函数不能被重写

3)用final来修饰一个成员变量，表示该成员变量的值不允许被改变，也就是是说，不允许重新赋值（哪怕是同一个值），因此，我们一般用final关键字来定义一个常量

object类

在Java中定义一个类时，如果没有用extends明确表明直接父类，那么该类默认继承object类。因此，object类是所有类的父类或间接父类。

在object中，比较常用的两个方法：

1)tostring 方法

2)equals 方法

注意：

1)父类的私有成员可以被子类继承，但只能通过继承自父类的，并且子类可以访问的方法（setter和getter访问器）

2)Java只支持单重继承

3)在构造子类对象时，父类的构造函数比子类的构造函数先运行输出（子类默认调用父类的无参构造函数）

4)抽象类不能被实例化

5)抽象类必须被重写，除非子类也是抽象类

6)在抽象类中可以含有普通成员函数