Java类,对象,接口

Java基础知识的类，对象，抽象类，接口的一个详细说明

类：主观抽象，是具有共同特性的对象的抽象，是对象的模板，可以实例化对象
定义格式：
package basic.com.base;//包名

import java.util.Date;//引入依赖包

public class Play {

int a =0; //属性

Date data = null;//属性

//默认构造器

public Play(){}

//带参数构造器

public Play(String name){...}

//方法

public void method1(){...}

}
        定义属性：实例变量
            格式：[ 修饰符 ] 类型变量名 [ = ? ]
            实例变量定义在类中,在方法体之外，受访问控制符限制。
            实例变量有默认值：各种各样的初始值，基本数据类型初始为基本的数据类型的默认值，对象类型的默认为null。
            在如果有重名作用域，实例变量和局部变量出现有命名冲突，采用“局部优先”原则。
        定义方法：
            格式： [ 修饰符 ] 返回类型方法名( 参数列表 ) [ throws 异常 ] { ······ }
            java中所有参数都是值传递。
当没有值返回时，返回类型必须被定义为void。
        构造器：
            在创建对象的过程中调用的方法。
            构造器没有返回类型。
            构造器的名字与类名相同。
            格式为：[ 修饰符 ] 类名( 参数列表 ){ }，修饰符可以是private、 protected、 default,public

  构造函数是提供对象创建，如果定义访问权限很小的构造函数，要考虑期初始的场景。
            在一个对象的生成周期中构造器只用一次，当类没有提供一个构造器，系统会自动提供一个无参的构造器。
            获得对象的方式：
                通过new（在堆空间中申请分配空间），new 类名()，可以通过这种形式创建一个对象，

这时的对象是无法使用，必须把他的地址存放进一个对象变量才能够使用。
                例如：
Person c=new Person();
建议：定义一个类的时候，保留一个无参的构造器

另外在类中注意一个this关键字：
1.在方法体重，this是个隐式参数，代表当前对象;
publie class Person{
private String name;
public void setName(String name){
this.name=name;        //this.name为了区分两个name,为当前对象的成员变量
}
}
2.在构造函数中使用this

public class Play {

//带参数构造器

public Play(String name){

System.out.println("name===" + name);

}

public Play(String name,int age){

this(name); //this 代表这个类的构造方法，这个this(...)必须放在改构造器第一行

System.out.println("2=====");

}

public static void main(String[] args) {

Play play = new Play("ddd",30);

}

}
注意： this不能出现在静态方法里面。
类、对象、实例三者的关系：
类：是对象的模板，可以实例化对象
对象：类的个体
实例：实现的对象
Person p; //根据模板可以定义很多的对象，都有Person的属性，例如 Person a,b,c;
p=new Person();
其中 Person 为类，p为对象，new Person()为实例，p 赋值后也是实例了。

方法重载（Overloading）：
方法重载是Java多态一个表现，多个同名函数同时存在，具有不同的参数个数/类型
注意：如果参数类型和个数都一样，不能只以返回值的差异来实现重载，一定要参数个数或者类型不一样
方法的重写（Overriding）

1>.父类与子类之间的多态性，对父类的函数进行重新定义。如果在子类中定义某方法与其父类有相同的

名称和参数，我们说该方法被重写 (Overriding)。在Java中，子类可继承父类中的方法，

而不需要重新编写相同的方法。

2>. 若子类中的方法与父类中的某一方法具有相同的方法名、返回类型和参数表，

则新方法将覆盖原有的方法。如需父类中原有的方法，可使用super关键字.
3>.子类函数的访问修饰权限不能少于父类的,对于定义的异常，子类抛出的异常类一定是父类的异常类的子类。
封装：
    类的属性加private修饰符，来限制只能够在类的内部进行访问，有效的保护数据。
    对于类中的私有属性，要对其给出一对方法getXxx()，setXxx()访问私有属性，保证对私有属性的操作的安全性。
    方法公开的是方法的声明，即只须知道参数和返回值就可以调用该方法，隐藏方法的实现的细节。
    一个对象和外界的联系应当通过一个统一的接口，应当公开的公开，应当隐藏的隐藏。
  放开读数据操作，限制写操作
继承：子类继承父类除private之外的属性和方法
一般就是把公用的属性，也就是共性形成一个父类，其他的个性的形成各自的子类
Java只支持单继承：一个类最多只有一个直接的父类。
   1.方法覆盖：
        方法名：相同
        参数表：相同
        访问限制符：相同或者更宽
        返回值类型：相同或者子类返回的类型是父类返回的类型的子类（在JDK5.0以后）
        抛出的异常：不能比父类更宽。
2.super关键字：
        super()表示调用父类的构造器
        super()也和this()一样必须放在方法的第一句
        super()和this()不能同时出现
        super可以屏蔽子类属性和父类属性重名时带来的属性遮盖，super. 表示调用父类的方法或属性
        在子类的构造器中如果没有指定调用父类的哪一个构造器，那么就会调用父类的无参构造器，即super()
    注意：
        父类的构造器不能被子类继承
        方法和属性可以被继承，权限不限制能否继承过来，子类的权限要大于父类的权限
        先构造父类，后构造子类，先this后super
多态：
    多态是一种运行期的行为

父类型的引用可以指向子类型的对象。

　　比如 Parent p = new Child();

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；

　　如果有，再去调用子类的该同名方法。

注意：静态static方法属于特殊情况，静态方法只能继承，不能重写Override，

如果子类中定义了同名同形式的静态方法，它对父类方法只起到隐藏的作用。

调用的时候用谁的引用，则调用谁的静态方法

如果想要调用子类中有而父类中没有的方法，需要进行强制类型转换

//编译错误
        //用父类引用调用父类不存在的方法
        //Animal a1 = new Cat();
        //a1.eat();
        
        //编译错误
        //向下类型转换时只能转向指向的对象类型        
        //Animal a2 = new Cat();
        //Cat c2 = (Dog)a2;

多态的作用：把不同的子类对象都当作父类来看，可以屏蔽不同子类对象之间的差异，写出通用的代码，

做出通用的编程，以适应需求的不断变化。

抽象类：abstract修饰类：
1.会使这个类成为一个抽象类，这个类将不能生成对象实例，但可以做为对象变量声明的类型，

也就是编译时类型
2.抽象类就相当于一个类的半成品，需要子类继承并覆盖其中的抽象方法，这时子类才又创建实例的能力，

如果子类没有实现父类的抽象方法，那么子类也要为抽象类。
3.可以有自己的数据成员，也可以有非 abstract的成员方法

抽象类

public abstract class SuperTmp {

public void work(){

System.out.println("===work");

}

public abstract void say();

}

实现类

public class Sub extends SuperTmp{

@Override

public void say() {

System.out.println("====sub say==");

}

public void happy(){

System.out.println("===happy===");

}

在调用的时候注意

SuperTmp tmp = new Sub();

tmp.say();//只能调用抽象类的方法，不能调用实现类的方法，tmp.happy(),编译会报错

abstract修饰方法：
1.实现部分以";"代替，需要子类继承实现。
2.抽象方法代表了某种标准，定义标准，定义功能，在子类中去实现功能（子类继承了父类并需要给出从

父类继承的抽象方法的实现）。
3.方法一时间想不到怎么被实现，或有意要子类去实现而定义某种标准，这个方法可以被定义为抽象。
注意：
有抽象方法的类一定是抽象类。但是抽象类中不一定都是抽象方法，也可以全是具体方法。

接口：因为java不支持多重继承，所以有了接口，一个类只能继承一个父类，但可以实现多个接口，

接口本身也可以继承多个接口。

1.接口里面的成员变量默认都是public static final类型的。必须被显示的初始化，不能修改

2.接口里面的方法默认都是public abstract类型的。。

3.接口没有构造方法，不能被实例化。

4.接口不能实现另一个接口，但可以继承多个接口。

5.类如果实现了一个接口，那么必须实现接口里面的所有抽象方法，否则类要被定义为抽象类

那么接口和抽象的汇总

1 接口只能包含抽象方法，抽象类可以包含普通方法，或者private方法，接口不能定义private方法。
2 接口只能定义静态常量属性，抽象类既可以定义普通属性，也可以定义静态常量属性。
3 接口不包含构造方法，抽象类里可以包含构造方法。

猜你喜欢