Java的类.对象和包

1·结构化编程与面向对象编程的区别

结构化编程是把整个程序作为一个过程,将之分割成一小段一小段的小步骤;
面向对象的编程是把整个程序分成若干对象,每个对象分别处理,最后再进行数据汇总。

2·java中的对象

Java是面向对象的编程语言 

对象是指在程序中生活中的所有可见可知并实际存在的一切物质----万物皆对象。
并且每个对象都具有特定的属性和方法。

3·类

类是具有相同属性和方法的若干对象的抽象体,它是一定数量的对象的集合。

****类是对象的抽象,对象时类的实例化。 ****

class,object,......

4·包

包是类的储存空间,是文件夹的具现化。

 

java的栈与堆

栈与堆是Java运行时由JVM分配的用于运行程序的内存空间。

栈与堆的特点有:

1·Java的数据都存放在栈与堆中;
2·Java方法都必须先入栈才能运行;
3·栈与堆比较,栈的空间小堆的空间大;
4栈的运行速度比堆要快;
5·基础数据和引用名在栈中,其他类型的数据以及引用的实体在堆里。

栈与堆的其他事项

方法入栈的原则是后进先出,即是先入栈的方法后出栈---入栈:last in first out

所有的方法执行 
方法在栈里面执行,执行过程中引用堆里的数据。

Java数据都存储在堆栈

栈 小 快 基础数据类型 堆 大 慢  引用数据类型

继承

Java中如果你没有构造函数,那么默认给你构造一个无参函数---

构造器 如果写了,则不再有默认无参构造函数 每次new的时候都调用构造器

重载--方法名相同,参数不同。--与返回值无关 根据不同参数,给出不同响应--在同一个类中

构造函数也是函数,   this()指向无参构造函数 --写在函数第一层

WWW--what where why ; H--how.---(学习效率)

classload --类加载器 引用:通过classload加载到内存中,再将指定的class类, 通过使用构造函数形成具体事例

Student s = new Student(); 

String 检查有没有这个class类---Student class--(副本) .Java .class

继承---子类subClass ,父类、基类superClass extends 关键字 当子类继承了父类之后,子类拥有父类的一切方法和属性

(privta除外) Java只能单继承 重写--发生在父类与子类之间,方法名与参数一模一样

Override\保证父子类的方法是一样的 调用方法时,如果子类没有重写就找父类 空属性(父类可写) 避免大量重复的代码

super调用父类的,this(调用无参)第一行,super和this在同一函数中只能调用一份 super.方法名

class-object

==判断内存地址是否相等 ==基础数据类型是判断值是否相等 String类型如果里面的值都一样,就不在开辟新空间

new String 强制开辟一个新空间 equals判断里面的值是否一样, 基础类型只有值,没有属性没有方法

final关键字 常量 变量 方法 class 进行修饰 修饰之后的变量不能再改变这个值 修饰后的方法不能被重写,可以被重载 修饰后的Class不能被继承

 

多态和抽象

1.多态

1.多态概述

继承-封装-多态-抽象----四大基本特征
弥补单继承功能的不足--主要用途
多态是指一个对象有多种形态的能力
都是调用同一个方法,由于传入的参数就执行了不同的方法
种族群---一类对象,子类与父类之间有Is-A的关系
两个种类:1是对象的不同,方法用同一个方法名--重载
2是同一对象根据不同响应执行不同的方法--重写

2.多态的技术基础

1 向上转型

子类的实例指向父类的引用,继承中向上转型
只能访问父类具有而且子类重写的方法,子类独有的方法无法访问 
向下類型轉換 不安全不科学的转换 转换语法

实例:

Animl a = new Dog();
Dog d = (Dog)a;
d.dogSay();
2 动态绑定

运行过程中的绑定,不同阶段使用不同方法,给出不同响应 
与之对应的静态绑定是运行前绑定,即是在程序执行之前就已经绑定好的类型

3 instanceof关键字

对象+instanceof+类:判断一个对象是否某个类的实例 结果是true或false

3 多态的主要应用

多态参数:引用上级类的参数,可以使用该上级类所属的任一参数

2 对象

只声明不实现的方法-子类必须实现,否则报错
定义一个方法让子类实现
父类方法实现没有意义
抽象方法--abstract --约束性
抽象方法必须写在抽象类里面
规定的抽象方法,其子类必须重写该方法,否则会报错
因为抽象类里面有未实现的方法,所以不能直接实例化

 

类的高级应用

1.修饰符的分类及应用

1.public-公开级别:

可以被任何的其他对象访问

public class InventoryItem {
private long partNumber;
public String description;
public InventoryItem(long n, String d) {
    partNumber = n;
    description = d;
}
}
public class DVDPlayer extends InventoryItem {  
public DVDPlayer(String make, String mode1, long partNumber) {
    super(partNumber, "DVD播放机");  
}  
}    
private void setRetailPrice(double p) {  
retailPrice = p;  
}

2.protected-受保护级别

可以被同一包中的类以及它自己的子类访问.

3.默认访问级别

没有访问修饰符,可以被同一包中其他类访问

4.private-私有访问级别

只有类的本身可以访问,不对外公开.

public class InventoryItem {
    private long partNumber;   
}

2.封装

封装是指类中的变量都是private类型,然后另提供public方法用以访问这些变量的技术。

3.静态变量,静态方法以及初始化块

以static修饰的成员变量或方法就是静态成员变量或方法 
不归一个类所有,归全体类共有的变量
只在类被初始化的时候,初始化一次
静态方法访问的外部变量必须是静态变量
调用的外部方法也必须是static修饰的方法
初始化块,用于初始化资源,时机比构造函数早,执行更快
static修飾初始化块时,将其变成静态初始化块
非静态的方法可以访问 静态属性或方法

public class Test(){  
    static int a = 10; //静态变量 
    public static void main(String[] arge){  
        system.out.println();  
    }    
    {  
      //初始化块
    }
    public class Home{    
        //静态方法
    }  
    static {  
        //静态初始化块
    }  
}

4.内部类

把一个类声明在另外一个类的内部就形成了一个内部类
她是在一个类的使用频率不高,没必要单独创建的时候出现的特殊类

class Outer{  
    class inner{  
    }  
}

1.静态内部类

用static修饰的内部类---static class
静态内部类可以访问外部类的属性和方法,
前提是外部类也是static修饰的(方法/属性) 
实例化静态内部类时无须先实例它所属的外部类

class a{  
    //a 方法语句  
        static{  
        }   
}

2.成员内部类

不要static的内部类

class Outer{  
    class inner{  
    }  
}

3.局部内部类

定义在其他类的某一个方法里面的类
只能再方法执行中使用,不能在方法外使用,方法出栈后就没有这个类

class test{  
    int a = 15;  
    public b(){  
        //b方法的语句    
        class{  
            int c = 20;  
        }  
    }  
}

接口

接口概述

特殊的抽象类 不能拥有构造函数,不能拥有实现的方法 不能被实例化
接口中的所有方法都是抽象方法,不需要加abstract
接口中的成员变量只能是静态常量--static final
接口不能被继承-----单继承 多实现
可以实现多个父类接口接口可以继承多个其他接口

是补充的同时也是一种规定
抽象类是对类的抽象,接口是对行为的抽象
接口是对单继承的补充,对行为限制的补充
是对行为的抽象 是一种约束

public interface  name {
  //抽象方法声明
  //static,final 成员变量(静态常量)
}

接口的应用

特殊的功能:暴露类的行为--强制类具有某些行为
如果一个类实现了某个接口,那么类中对象就具备了该接口数据类型的特点
接口的引用指向实现类的实例
多态参数-所有实现该接口的类都可指向--类似于父类继承

异常处理

检查异常 运行异常 错误 错误是指正常程序不应该试图捕获的严重问题

由一些非程序本身的不可抗拒的其他因素产生 运行时异常指程序执行过程中产生的可以避免的异常

name.printStackTrace--打印异常   Throwable(父类)---Eception(异常)-Error(错误)

异常处理的三种方式: 捕获并处理--捕获但抛出--不捕获

try{监控}catch{捕获}finally{收尾} 不管有无异常finally语句块都会被执行

异常处理的必要性:如果程序中有异常,该程序就不会再向下执行 如果捕获了异常,则程序可以从下一个方法再继续往下执行

捕获异常从小往大抓(继承顺序); 声明异常,谁调用谁处理

throws声明一个可能产生的异常 throw抛出一个具体的异常 throw语句将导致当前代码立即停止执行

getMessage 获得被调用方法抛出的异常

抛出异常:抛到用户能看到的地方

ArrayIndexOutOfBoundsException 数组索引越界
FileNotFoundException 找不到文件
IOException 输入输出异常

。。。。。。