Java基础知识笔记第四章：类和对象

 

 编程语言的几个发展阶段

　　面向机器语言

　　面向过程语言

　　面向对象语言：封装、继承、多态

类

　　类声明

class  Person{
    .......   
}

class 植物{

    .......

}    

　　类体

　　　　　　类使用类体来描述所抽象出的属性 行为，类声明后的一对大括号{ ....... }以及他们之间的内容称作类体

　　　　　　变量的声明：依赖存储属性的值（体现对象的属性）

　　　　　　方法的定义：方法可以对类中声明的变量进行操作即给出算法；

成员变量

　　　　　　成员变量类型：整型，浮点型，字符型，逻辑类型，引用类型：数组类型，对象，接口

　　　　　　成员变量的有效范围：成员变量在整个类内都有效；

　　方法

　　　　　　

方法头{

    方法体

}

方法头：开放权限级别   返回类型    方法名

1.区分成员变量和局部变量
2.局部变量没有默认值

　　需要注意的问题

class A{
int a=12;
int b=13;
}
/*
声明的时候同时赋值
*/

class A{
int a;
int b;

a=10;
b=44;

}
/*
错误的写法，语句不是变量的声明，只能在方法体中出现
*/

　　类的UML图

构造方法与对象的创建

　　构造方法：无返回类型，方法名与类同名

　　　　　　　　　默认构造方法：如果类内没有定义该类的构造方法；这默认生成默认的无参的构造方法；倘若类内有定义一个或者多个构造方法这系统不默认生成无参构造方法；

　　创建对象

　　　　　　　　格式：Class_Name    Object_name

　　　　　　　　　　　　Class   A;

　　　　　　　　new Class_Name:返回的是该类在堆区中开辟内存的引用；对象的引用在栈区中，对象的实体在堆区中；

　　使用对象

　　　　　　　　对象操作自身的变量：格式：对象.变量

　　　　　　　　对象操作自身的函数：格式：对象.函数名（）

　　对象的引用和实体

　　　　　　　　Class   A；   Class B;

　　　　　　　　A    a  =   new    A();

　　　　　　　　A    b=a;//注意b中存放着是a的值；b即为a的引用；

　　　　　　　垃圾收集：一个类声明的两个对象如果具有相同的引用，那么二者就具有完全相同的实体，而且java有所谓的“垃圾收集”机制，这种机制周期性的检查某个实体是否已　　　　　　　　经不再被如何对象所拥有（引用），如果发现这样的实体就释放实体占用的内存；

　　　　　　　如果希望java虚拟机立即进行垃圾收集，操作，可以让System类调用gc()方法；

类与程序的基本结构

　　　　　　　主类：含有main方法的类；

　　　　　　　编译某个目录下的全部java文件：Javac  *.java

参数传值

　　传值机制

　　　　　　　　　传入方法的值是拷贝的数据，所以修改其值不影响原件；

　　基本数据类型的传值

　　　　　　　　　向该参数传递的值的级别不可以高于该参数的级别；例如：不可以向一个int型的参数传递float类型值；

　　引用类型的传值

　　　　　　　　　改变参数变量中所引用的实体；就会导致原变量的实体发生同样的变化；

　　　　　　　　　改变参数中存放的“引用”不会影响向其传值的变量中存放的“引用”，反之亦然；

　　可变参数

　　　　　　　　　定义：在方法声明时不给出参数列表中从某项开始至最后一项参数的名字，和个数但是这些参数的个数必须相同；

　　　　　　　　　格式：用   ...  表示若干参数，这些参数类型必须相同；

　　　　　　　　　　　　

public   void   fun(int   ... x)

　　　　　　　　　

public   void   fun(double  d,int   ... x)

//错误的写法
public void  method（int ...x ，int  y）
/*
错误的使用了可变参数x,因为可变参数x代表的最后一个参数表示method 的最后一个参数，method的最后一个参数y不是可变参数x所代表的参数之一

*/

java1.fun(1,2,3,4,5,6,7,8,9);
public static int  fun(int ...x){
            for(int k:x){
                System.out.println("result="+k);
            }
        return 0;
}

对象的组合

　　组合和复用

　　　　　　　　　　组合：一个类中包含另一个类；

　　　　　　　　　　（1）：通过组合对象来复用方法也称为“黑盒”复用，因为当前对象只能委托所包含的对象调用其方法，这样一来，当前对象所包含的对象的方法的细节（算法的　　　　　　　　　　　　　　细节）是一无所知的

　　　　　　　　　　（2）：当前对象随时可以更换所包含的对象，即对象所包含的对象属于弱耦合关系

　　类的关联关系和依赖关系的UML图

实例成员变量与类成员

　　实例成员变量和类变量的声明

class  Dog{
　　float   x;         //实例变量(属于对象）
　　static  int   y;   //类变量（属于类）
}    

　　实例成员变量和类变量的区别

1.不同对象的实例变量互不相同
2.所有对象共享类变量
3.通过类名直接访问类变量/方法

当java程序执行时，类的字节码文件被加载到内存，如果改类没有创建对象，类中的实例变量不会被分配内存，但是，类的类变量，在该类被加载到内存时，就分配相应的内存空间。

类的变量的内存空间直到程序退出运行才释放占有的内存空间！

　　实例方法和类方法的定义

class A{

int a;
float max(float x,float y){//实例方法
    }
static float jerry(){//类方法
    }
static  void  speak(String s){//类方法
    }
}

　　实例方法和类方法的区别

当类的字节码文件被加载到内存时，类的实例方法不会被分配入口地址，只有创建该类的对象之后，类中的实例方法才分配入口地址，从而实例方法可以被创建的任何对象调用执行需要注意的是，
当我们创建第一个对象时候，类的实例方法就分配了入口地址，当再创建对象时，不在分配入口地址。也就是说方法的入口被所有的对象共享，当所有的对象都不存在的时候，方法的入口地址才被取消！

1.也可以通过类名直接调用类方法

设计类方法的原则：
　　1.对于static方法，不必创建对象就可以用类名直接调用他（创建对象会导致类中的实例变量被分配内存空间），如果一个方法不需要操作类中的任何实例变量，就可以满足程序的需要，则可以设计为static方法

方法重载

　　方法重载的语法规则

**参数的个数不同
**参数个数相同，但是参数列表中的某个参数的类型不同

class A{

float fun(int a){
    }   
float fun(int a,int b){
    } 
float fun(int a,float b){
    } 
}

　　避免重载出现歧义

package chapter_4;

/**
 * @author Mikey
 * @date 2018/10/1 16:47
 */
public class Dog {
    static void cry(double m,int n){
        System.out.println("小狗");
    }
    static void cry(int n,double m){
        System.out.println("小猫");
    }
    public static void main(String[] args){
        
        Dog.cry(10.0,10);
        Dog.cry(10,10.0);
        Dog.cry(10,10);//出现歧义
    }
}

this关键字

　　在构造方法中使用this

this  代表当前对象

　　在实例方法中使用this

this.成员变量
this.成员方法

class  A{
    int x;
    static int y;
    void f(){
 this.x=100;
 A.y=10;          
}

一个实例方法调用另一个方法时可以省略方法名字前的this.或者 类名
例如

class B{
void  f(){
    g();
    h();
}

void  g(){
    System.out.println("g");
}
void  h(){
    System.out.println("h");
}

}

//注意：this不能出现在类方法中，这是因为类方法可以通过类名直接调用，这时可能还没有任何对象的创建诞生

包

　　包语句

package  包名

package  包名.包名.包名

　　有包名的类的存储目录

package   tom.jiafei

javac   tomjiafei源文件

　　运行有包名的主类

java tom.jiafei.主类名

java语言不允许用户程序使用java作为包名的一部分，例如java.bird是非法的包名（发生运行异常）

import语句

　　引入类库中 的类

import java.util.*；//导入java.util包下的所有类

//如果不想引入包下的类,则直接带上包名使用
java.util.Date date=new java.util.Date();

　　引入自定义包中的类

import 包名.*；//导入该包下的所有类

.*   代表所有的类
.；  代表加载应用程序当前目录下的无名包类

访问权限

　　何谓访问权限

所谓的访问权限，是指对象是否通过 “.” 运算符操作自己的变量/方法

　　私有变量和私有方法

//使用private修饰的变量/方法
class Tom{
 private float weight;
priavte  float fun(float a,float b){
  return a+b;   
   }   
}

　　共有变量和共有方法

//使用public修饰的变量/方法
class Tom{
 publicfloat weight;
publicfloat fun(float a,float b){
  return a+b;   
   }   
}

　　友好变量和友好方法

/*定义
*不用private   public    protected 修饰的成员变量/方法
*
*/
class Tom{
    float weight;
    float f(float a,float b){
        return a+b;
    }
}

　　受保护的成员变量和方法

class Tom{
   protected float weight;
   protected float f(float a,float b){
        return a+b;
    }
}

　　public类与友好类:注意java中只有这两种来修饰类

//友好类
class A{}
//公共类
public class A{}

基本类型的类封装

　　以下的对象带参构造方法都可以将基本数据类型封装成对象

　　　　Double和Float

　　　　Byte  Short  Integer   Long  类

　　　　Character类

对象数组

格式1：类名[ ]  对象数组名=new  类名[大小]

jre拓展与jar文件

//jre  java  runtime  environment
//jar  将java类打包为jar格式文件，放入拓展中，程序就可以直接import来使用了

文档生成器

/*
*使用JDK  提供的javadoc.exe可以制作源文件类结构的HTML格式文档
*/


javadoc  Example.java

//-d 来指定目录

javadoc -d F:mikeyjava Example.java

小结：