一 基础部分
1.基本数据类型
Java的八种基本数据类型不支持面向对象的编程机制,不具备“对象”的特性:没有成员变量、方法可以调用。java之所以提供这八种基本数据类型,是为了照顾程序员的传统习惯。所有的引用类型的变量都继承了Object类,都可以当成Object类型变量使用,但是基本数据类型就不可以, 为了解决这个问题,Java提供了包装类。JDK1.5提供了自动装箱和自动拆箱功能,自动装箱是指,可以把一个基本数据类型的变量直接赋给对应的包装类变量或者是Object变量;自动拆箱是指允许直接把包装类对象直接赋给一个对应的基本类型变量。这里要注意,自动装箱和自动拆箱时必须要类型匹配,如 Integer只能自动拆箱成int,不能拆成boolean。
2.包装类
包装类还可以基本实现基本类型变量和字符串的转换,把字符串转换成基本类型有两种方式:
利用包装类提供的parseXxx(String s)静态方法;
利用包装类提供的Xxx(String s)构造器;
如:
String intStr="123";
int it1=Integer.parseInt(intStr);
int it2=new Integer(intStr);
3.String类的转换
String类提供了多个重载value()方法,用于将基本类型变量转换成字符串:
int it3=111;
String s=String.valueOf(it3);
String booleanStr=String.valueOf(true);
还有一种更简单的方法,将基本类型和""进行连接运算:
String s=5+"";
4.包装类和基本数据类型的数据比较
包装类型的变量虽然是引用数据类型,但是包装类的实例可以与数值类型的值进行比较,这种比较是直接取出包装类实例所包装的数值来比较的,如:
Integer a=new Integer(6);
System.out.println("6的包装类实例是否大于5.0"+(a>5.0));
两个包装类的实例比较
只有两个包装类引用指向同一个对象时才会返回true,如:
new Integer(2)==new Integer(2);   //false
由于自动装箱功能,可能会出现一些特别的情况,如:
Integer a=2;
Integer b=2;
a==b; //true
Integer c=128;
integer d=128;
c==d; //false
这里主要与java的Integer类的设计有关,系统自动把-128~127之间的整数自动装箱成Integer实例,并放入了一个Cache的数组中缓存起来,所以-128~127之间的同一个整数自动装箱成一个Integer实例时,实际上引用的是cache数组里的同一个数组元素,而在这范围之外的整数,系统总是重新创建一个Integer实例,所以引用的不是同一个对象。
5.toString()方法
如果在程序中定义了一个Person类

class Person{
private String name;
public Person(String name){
this.name=name;
}
}
public class PrintObject{
public static void main(String[] args){
Person p=new Person("lyy");
System.out.println(p);
}
}

打印出这个对象,结果为Person@15db9742,实际上Person实例是一个内存中的对象,不可以直接转换成字符串输出。但是实际上,这里输出 的是Person对象的toString()方法的返回值,这里的p跟p.toString()效果是一样的。toString()方法是一个“自我描 述”方法,当程序员直接打印该对象时,系统会输出该对象的自我描述信息,用以告诉外界该对象具有的状态信息。toStrng()方法返回的是“类名+@+hashCode”

6.==和equals方法

用==进行判断时,如果都是基本数据类型,且值相等,就返回true;如果是两个引用类型,只有指向同一个对象,==判断才会返回true,如:

int a=65;
float b=65.0f;
a==b; //true
char c='A';
a==c; //true
String str1=new String("hello");
String str2=new String("hello");
str1==str2; //false
str1.equals(str2); //true
String str3="hello";
String str4="hello";
str3==str4; //true
这里的hello和new String("hello")的区别是:当程序直接使用形如"hello"的字符串直接量(也包括可以在编译时直接就能计算出来的字符串值)时,JVM 将会使用常量池来管理这些字符串,常量池保证相同的字符串直接量只有一个,不会产生多个副本;当使用String类的构造器来创建一个新的String对象,新创建的String对象被保存在堆内存中,该对象是运行时创建出来的。
可以将equals()方法重写,如:
public class Person{
private String name;
private String idStr;
public Person(String name,String idStr){
this.name=name;
this.idStr=idStr;
}
public boolean equals(Object obj){
//如果两个对象是同一个对象
if(this==obj) return ture;
//只有当obj是Person对象
if(obj!=null&obj.getClass()==Person.class){
Person p=(Person)obj;
//并且当前对象的idStr与obj对象的idStr相等时才可以判断两个对象相等
if(this.getIdStr().equals(p.getIdStr())) {
return true;
}
}
return false;
}
}

7.static关键字

(1)static关键字修饰的成员就是类成员,static关键字不能修饰构造器,static修饰的类成员属于整个类,不属于单个实例。类变量生存范围几乎等同于该类的生存范围,当类完成初始化时,类变量也被初始化。类成员不能访问实例成员,因为类成员属于类,类成员的作用域比实例成员的作用域更大,完全可能出现类成员已经初始化完成,但实例成员还不曾初始化的情况。
(2)类变量也可以通过该类的对象来访问,但实际上并不是访问该对象所拥有的变量,因为系统在创建该类的对象时,并不会再一次为类变量分配内存,也就是说,对象根本不拥有对应类的类变量,只是系统会在底层转换为通过该类来访问类变量。
(3)单例类
有些时候,允许其他类自由创建该类的对象没有任何意义,还可能造成系统性能下降,因为频繁的创建对象、回收对象带来的系统开销的问题。比如系统只有一个窗口管理器,一个假脱机打印设备或一个数据库引擎访问点。
单例模式的几个特点:避免其他类自由创建该类的实例,构造器使用private,然后提供一个public方法作为该类的访问点来创建该类的对象,该方法只 能是static。另外,该类还必须缓存已经创建的对象,否则该类无法知道是否已经曾经创建过对象,也就无法保证只创建一个对象。因此该类需要使用一个成员变量来保存曾经创建的对象,因为该成员变量需要被上面的静态方法访问,故此成员变量必须使用static修饰。
单例模式是一种常见的设计模式,主要是两种:懒汉式和饿汉式
懒汉式
public class Singleton{
private static Singleton instance=null;
private Singleton(){}
public static Singleton getInstance(){
if(instance==null){
instance=new Singleton();
}
return instance;
}
}

饿汉式

public class Singleton{
private static Singleton instance=new Singleton();
private Singleton(){}
public static Singleton getInstance(){
return instance;
}
}

8.final

final关键字可用于修饰类、变量和方法,final修饰的变量不可被改变,一旦获得了初始值,该final变量的值就不能被重新赋值。

final可提高程序响应效率,声明成final的情况:

(1)不需要重新赋值的变量,包括类属性、局部变量;

(2)对象参数前加final,表示不允许修改引用的指向;

(3)类方法确定不允许被重写;

二 内部类

1.内部类的作用:
(1)内部类提供了更好的包装,可以把内部类隐藏在外部类之内,不允许同一个包中的其他类访问该类;
(2)内部类成员可以直接访问外部类的私有数据,但外部类不能访问内部类的实现细节,如内部类的成员变量;匿名内部类适用于创建那些仅需一次使用的类;
(3)内部类比外部类可以多使用三个修饰符:private protected static;
(4)非静态内部类不能拥有静态成员
2.内部类主要有非静态内部类和静态内部类

(1)非静态内部类:

public class Cow {
private double weight;
public Cow(double weight) {
this.weight = weight;
}
public Cow() {
}
//非静态内部类
private class CowLeg{
private double length;
private String color;
public CowLeg(double length, String color) {
this.length = length;
this.color = color;
}
public CowLeg() {
}
public void info(){
System.out.println("牛腿颜色:"+color+",高:"+length);
//可以访问到外部类的private修饰的成员变量
System.out.println("奶牛重:"+weight);
}
}
public void test(){
CowLeg cl=new CowLeg(1.12,"白加黑");
cl.info();
}
public static void main(String[] args){
Cow cow=new Cow(378.9);
cow.test();
}
}

注意:如果外部类成员变量、内部类成员变量和内部类方法里的局部变量同名,可以通过使用this,外部类类名.this来区分,如:

public class DiscernVariable {
private String prop="外部类的实例变量";
private class innerClass{
private String prop="内部类的实例变量";
public void info(){
String prop="局部变量";
//外部类的实例变量
System.out.println(DiscernVariable.this.prop);
//内部类的实例变量
System.out.println(this.prop);
//局部变量
System.out.println(prop);
}
}
public void test(){
innerClass in=new innerClass();
in.info();
}
public static void main(String[] args){
new DiscernVariable().test();
}
}

通过上面两个例子我们可以发现,如果存在一个非静态内部类对象,那么久一定存在一个被它寄生的外部类对象,如:

public class Outer {
private int outProp=9;
class Inner{
private int inProp=5;
public void accessOutProp(){
System.out.println("外部类的outProp的值:"+outProp);
}
}
public void accessInnerProp(){
//这段代码出现编译错误,外部类不能直接访问非静态内部类的实例变量
// System.out.println("内部类的inProp的值:"+inProp);
//必须要显式创建内部类来访问内部类的实例变量
System.out.println("内部类的inProp的值:"+new Inner().inProp);
}
public static void main(String[] args){
//只是创建了外部类对象,并没有创建内部类对象
Outer out=new Outer();
out.accessInnerProp();
}
}

(2)静态内部类

public class StaticInnerClassTest {
private int prop1=5;
private static int prop2=3;
static class StaticInnerClass{
private static int age;
public void accessOurProp(){
//无法访问外部类的实例变量
// System.out.println(prop1);
System.out.println(prop2);
}
}
}

3.在外部类以外使用内部类

(1)非静态内部类:

class Out{
class In{
public In(String msg){
System.out.println(msg);
}
}
}
public class CreateInnerInstance {
public static void main(String[] args){
Out.In in=new Out().new In("测试信息");
}
}
非静态内部类的构造器必须使用外部类对象来调用
(2)静态内部类:
class StaticOut{
static class In{
public StaticIn(String msg){
System.out.println("静态内部类的构造器");
}
}
}
public class CreateStaticInnerInstance {
public static void main(String[] args){
StaticOut.StaticIn in=new StaticOut().StaticIn();
}
}

java 面向对象一的更多相关文章

  1. JAVA面向对象

    JAVA面向对象 对象   我们生活中能看到能摸到的一切事物都是对象.在程序中模拟出生活中的所有东西万物皆对象   只要是对象--属性和行为(方法)   属性   对象有什么   例如:学生有姓名.学 ...

  2. 理解JAVA - 面向对象(object) - 属性,方法

    理解JAVA - 面向对象(object) - 属性,方法 多态的体现:    向上造型,父类接收子类对象:向上造型:    从父类角度看不到子类独有的方法:面向对象,人类认知世界的方式:生活中每天都 ...

  3. Java面向对象㈠ -- 封装

    Java的面向对象有三大特征:封装.继承.多态.这里主要对封装进行讲解. 封装可以理解为隐藏一个类的成员变量和成员函数,只对外提供需要提供的成员函数. Java的封装主要通过访问权限控制符:priva ...

  4. 谈谈Java面向对象的三大特性

    Java面向对象的三大特性就是指封装.继承.多态了. 一.封装: 概念:封装是指隐藏对象的属性和实现细节,仅对外提供公共访问方式. (举例:笔记本电脑就是一个封装体,Java语言中最小的封装体就是函数 ...

  5. Java面向对象:接口

    Java面向对象之接口 什么是接口:接口是一种规范和标准,他们可以约束类的行为,是一些方法特征的集合 语法: [修饰符] interface 接口名 extends 父接口1,夫接口2....... ...

  6. 实验二 Java面向对象程序设计

    实验二 Java面向对象程序设计 实验内容 1. 初步掌握单元测试和TDD 2. 理解并掌握面向对象三要素:封装.继承.多态 3. 初步掌握UML建模 4. 熟悉S.O.L.I.D原则 5. 了解设计 ...

  7. java基础1.0::Java面向对象、面向对象封装、抽象类、接口、static、final

    一.前言 一直以来都是拿来主义,向大神学习,从网上找资料,现在就把自己在工作中和学习中的所理解的知识点写出来,好记星不如烂笔头,一来可以作为笔记自己温习,二来也可以给走在求学之路的同学们一点参考意见, ...

  8. 20145212《Java程序设计》实验报告二 《 Java面向对象程序设计》

    20145212 实验二< Java面向对象程序设计> 实验内容 单元测试 三种代码 伪代码 百分制转五分制: 如果成绩小于60,转成"不及格" 如果成绩在60与70之 ...

  9. 20145213《Java程序设计》实验二Java面向对象程序设计实验报告

    20145213<Java程序设计>实验二Java面向对象程序设计实验报告 实验内容 初步掌握单元测试和TDD 理解并掌握面向对象三要素:封装,继承,多态 初步掌握UML建模 熟悉S.O. ...

  10. 20145206《Java程序设计》实验二Java面向对象程序设计实验报告

    20145206<Java程序设计>实验二Java面向对象程序设计实验报告 实验内容 初步掌握单元测试和TDD 理解并掌握面向对象三要素:封装.继承.多态 初步掌握UML建模 熟悉S.O. ...

随机推荐

  1. 区间DP学习总结

    这段时间学习了区间DP,所以试着把学到的东西稍作总结,以备不时之需. 学习区间DP首先要弄清区间DP是为了解决什么问题:一般的DP主要是特征是一次往往只操作一个数值或者存储可以不连续的物品的状态(比如 ...

  2. Failed to read candidate component错误

    <context:component-scan base-package="com.spdb"/> <mvc:annotation-driven/> 加上该 ...

  3. 2.为ADF应用添加安全性认证

    1.打开ADF应用之后,选择Application==>Secure==>Configure ADF Security 2.在弹出框中选择ADF Authentication,一直Next ...

  4. im2rec打包图片

    https://mxnet.incubator.apache.org/faq/finetune.html python ~/mxnet/tools/im2rec.py --list --recursi ...

  5. C#读取信息备份

    class Program { static void Main(string[] args) { var wc = new WebClient(); var html = wc.DownloadSt ...

  6. Java之生成Pdf并对Pdf内容操作

    虽说网上有很多可以在线导出Pdf或者word或者转成png等格式的工具,但是我觉得还是得了解知道是怎么实现的.一来,在线免费转换工具,是有容量限制的,达到一定的容量时,是不能成功导出的;二来,业务需求 ...

  7. Jmeter--HTTPS请求

    (1)新建threadGroup:                               (2)设置并发用户数量:                                     (3) ...

  8. python对文件进行读写操作

    转:http://sucre.iteye.com/blog/704077 ython进行文件读写的函数是open或file file_handler = open(filename,,mode) Ta ...

  9. sharepoint OOS巨大坑

    首先,我们安装的操作系统是windows server 2016 datacenter最新版,然后安装了OOS2016年的那个版本,打好语言包,安装必备软件,所有的步骤都没问题,但是你配置OOS场的时 ...

  10. Oracle split分区表引起ORA-01502错误

    继上次删除分区表的分区遇到ORA-01502错误后[详细见链接:Oracle分区表删除分区引发错误ORA-01502: 索引或这类索引的分区处于不可用状态],最近在split分区的时候又遇到了这个问题 ...