- 浏览: 243179 次
- 性别:
- 来自: 北京
文章分类
- 全部博客 (192)
- 技术研究学习 (19)
- 工作总结 (4)
- spring3.x (11)
- mail (2)
- jar (2)
- FCKeditor (1)
- quartz (2)
- json (1)
- jdbc (5)
- struts2 (6)
- java基础 (18)
- jboss (3)
- IT名称解析 (1)
- 测试工具 (2)
- 工作趣谈 (1)
- 数据库 (8)
- js (8)
- jquery (1)
- mysql (20)
- Sql (3)
- Oracle (1)
- easyui (0)
- log4j (1)
- 源码研究 (1)
- Jasper Report (0)
- Jbpm4 (4)
- xml (1)
- ireport (0)
- javavm (1)
- sitemesh (5)
- compass (1)
- jvm (1)
- ext (1)
- lucene (0)
- cxf (1)
- Blazeds (0)
- Resteasy (1)
- jaxb (1)
- tomcat (1)
- Rmi (1)
- BoneCP (1)
- velocity (3)
- OSCache (1)
- EHCache (1)
- 高性能开发 (9)
- 设计模式 (0)
- 网络协议应用 (1)
- Ibatis (1)
- powerdesigner (1)
- 架构师之路 (2)
- memcached (4)
- MapReduce (1)
- 测试组 (1)
- 图像处理 (2)
- LoadRunner (2)
- 报表 (1)
- 负载均衡 (1)
- 分布式 (3)
- c# (1)
- java中一些特殊问题 (3)
- java 8 (1)
- Mogodb (1)
- 项目设计与实现 (2)
- Ubuntu (1)
- eclipse (1)
- gradle (1)
- 私有云 (1)
- redis (1)
- 移动前端 (1)
最新评论
对象一般都有两个特征:状态和行为
类实质上定义的是一种数据类型,这种数据类型就是对象类型。所以
我们可以使用类名称来声明对象变量
类实例化:
public class Point {
/**
* @param args
*/
int x;
int y;
void output()
{
System.out.println(x);
System.out.println(y);
}
public static void main(String[] args) {
// TODO Auto-generated method stub
Point pt;
pt = new Point();
pt.x = 10;
pt.y = 10;
pt.output();
}
}
思路的转变:
我们通常习惯于考虑解决问题的方法,而不是考虑将问题抽象成对象再去解决它。
函数可以用修饰字符么?――― 一般什么都不用
类中 This.变量 和 变量 有没有使用上的区别?
-----区别类中的全局变量和同名的局部变量 this.x = x;
――this还可以简化构造函数的调用:必须在函数体的第一行
public class Point {
int x;
int y;
Point()
{
this(1,1);//必须在函数体的第一行
}
Point(int a,int b)
{
x=a;
y=b;
}
void output()
{
System.out.println(x);
System.out.println(y);
}
public static void main(String[] args) {
Point pt;
pt = new Point();
pt.output();
}
}
方法的重载overload:方法的名称相同,但参数类型或个数不同,才能构成方法的重载
多个构造方法:
public class Point {
int x;
int y;
Point()
{
x=5;
y=5;
}
Point(int a,int b)
{
x=a;
y=b;
}
void output()
{
System.out.println(x);
System.out.println(y);
}
public static void main(String[] args) {
Point pt;
pt = new Point();
pt.output();
Point pt2;
pt2 = new Point(6,6);
pt2.output();
}
}
new 关键字的作用
1 为对象分配内存空间
2 引起对象构造方法的调用
3 为对象返回一个引用
一个类所有的实例调用的成员方法在内存中只有一份拷贝
pt.output()
pt2.output()
output方法只有一份拷贝,而实例成员可以存在多个拷贝
static方法,可以直接使用 类名.static方法 调用
在静态方法中不能调用非静态的方法和引用非静态的成员变量。反之,则可以。
public class Point {
int x;
static void output()
{
System.out.println("333");
}
public static void main(String[] args) {
Point.output();
}
}
静态方法只属于类本省,不属于对象,静态方法也叫类方法,非静态方法叫做实例方法。
如果改动一下:
static void output()
{
System.out.println(x);
}
这样会报错,因为直接使用类名.static方法调用是没有生成对象的,没有对象那么也就没有对象成员x.的内存空间【内存模型概念,没有内存空间都是不能被调用的】。如果一定要输出x,那么就要声明为静态变量,类变量。
public class Point {
static int x = 3;
static void output()
{
System.out.println(x);
}
public static void main(String[] args) {
Point.output();
}
}
静态成员:
public class Point {
static int x;
public static void main(String[] args) {
Point pt = new Point();
Point pt2 = new Point();
pt.x=1;
pt2.x=2;
System.out.println(pt.x);
System.out.println(pt2.x);
//两个对象共享同一个静态变量,静态变量属于类本身,而不是属于对象
}
}
常量:通常大写,并推荐声明为静态。值不能被修改.声明的时候要初始化,也可以在构造函数中初始化。但是当声明是静态的常量,那么一定必须在声明的时候初始化,直接使用类名.类变量来访问的时候常量没有被赋值就是错误的。
final double PI = 3.1415926;
Extends 继承
Java不也许多继承,即是一个类不也许同时继承多个类
方法的覆盖:在子类中定义一个与父类同名,返回类型,参数类型均相同的一个方法。
当实例化子类的时候,父类的构造方法先与子类的构造方法被调用
class Person
{
int height;
Person()
{
System.out.println("Person construct");
}
}
class Fish extends Person
{
int height;
Fish()
{
System.out.println("Fish construct");
}
}
class Animal
{
Animal()
{
}
public static void main(String[] args) {
Fish fh = new Fish();
}
}
构造方法不能被继承
多态性:通过覆盖父类的方法来实现,在运行时根据传递的对象引用,来调用相应的方法。
class Person
{
int height;
Person()
{
System.out.println("Person construct");
}
void breathe()
{
System.out.println("Person breathe");
}
}
class Fish extends Person
{
int height;
Fish()
{
System.out.println("Fish construct");
}
void breathe()
{
System.out.println("Fish breathe");
}
}
class Animal
{
Animal()
{
}
static void fn(Person ps)//对象引用的传递,原本传递的父类,但是可以被子类替换
{
ps.breathe();
}
public static void main(String[] args) {
Fish fh = new Fish();
Person ps;
ps = fh;
Animal.fn(ps);
}
}
/*
Person construct
Fish construct
Fish breathe
*/
判断一个对象是否是××的实例instanceof
if(an instanceof Animal)
{
}
子类也是父类的实例
Package 主要是避免类名相同的麻烦。Java文件中package 必须位于第一行
Javac –d . Test.java -d可以自动生成package所对应的目录层次 .表示当前目录,也可以指定目录 javac –d d:\test Test.java
Java com.Test
Import java.io.File;
Import java.io.*;
在同一个包中的类可以相互引用,无需import语句
如果不import,可以这样申明对象f:java.io.File f;
批量编译javac –d . *.java
类的修饰符
类的访问说明符:public default 控制别的包,类引用
public 可以被不同包引用,java内置的包都是public
default 只能被同包中的类引用
其它修饰符:final abstract
final 最终的包,不能再派生 java.lang.string 就是final
abstract 抽象类,配合抽象方法。抽象类不能被实例化。子类要实现父抽象类的所有抽象方法,否则这个子类也要声明为抽象类。我们可以将一个没有任何抽象方法的类声明为抽象类,避免由这个类产生任何的对象。
有的可以同时使用:
public final class Test
public abstract calssTest
接口:所有的方法都是抽象方法
方法的修饰符
方法的访问说明符:public(java内置的方法都是public) protected default(只能在同包中访问) private(卧室概念,只能在同类中所访问)
protected 的通用性不能被使用是怎样的情况----不同的包只有是父子类的关系才能被访问,不是父子类关系的不同包是不能访问的。也就是有父子关系的类可以使用
其它修饰符:static final abstract native synchronized
final 不能被覆盖的类,private 或 static 修饰的方法都是 final ,子类中重写static方法,只是生成了另一个static方法,并没有覆盖父类中的static
abstract 写法: protected abstract void test(); 有抽象方法的类必须声明为抽象类。抽象类不能被实例化。子类要实现父抽象类的所有方法,否则这个子类也要声明为抽象类
接口 interface
class **(类) implements(实现) **(接口)
interface **(接口) extends(继承) **(接口)
接口的派生类必须实现接口里所有的方法,否值必须把该类声明为抽象类
派生类的方法一律不得低于public
接口中的所有的方法都是public abstract ,不能对接口中的方法使用其它修饰符
接口中的成员变量默认为public static final
接口类一般声明为public
java中允许接口的多继承,不允许其它类的多继承
允许一个类实现多个接口,一个类在继承的同时可以实现多个接口。
如何返回接口的成员
接口实例:电脑主板显卡
内部类
内部类编译后的文件名为:Outer$Inner.class
Outer.java
class Outer {
private int index=100;
class Inner
{
void print()
{
System.out.println(index);//内部类可以外部的访问private 的成员变量
}
}
void print()
{
Inner inner=new Inner();
inner.print();
}
}
Test.java
class Test {
public static void main(String[] args) {
Outer outer=new Outer();
outer.print();
}
}
内部类可以随意访问外部类的所有成员变量和方法。
访问外部类和内部类的成员变量
Outer.java
class Outer {
private int index=100;
class Inner
{
private int index=50;
void print()
{
int index=30;
System.out.println(index);//30
System.out.println(this.index);//50
System.out.println(Outer.this.index);//100
}
}
void print()
{
Inner inner=new Inner();
inner.print();
}
}
Test.java
class Test {
public static void main(String[] args) {
Outer outer=new Outer();
outer.print();
}
}
实例内部类
Outer.java
class Outer {
private int index=100;
class Inner
{
private int index=50;
void print()
{
int index=30;
System.out.println(index);
System.out.println(this.index);
System.out.println(Outer.this.index);
}
}
void print()
{
Inner inner=new Inner();
inner.print();
}
Inner getInner()//返回值是对象
{
return new Inner();
}
}
Test.java
class Test {
public static void main(String[] args) {
Outer outer=new Outer();
Outer.Inner inner=outer.getInner();//不能直接访问内部类,Inner inner=outer.getInner();是错误的写法,必须加上它的前缀外部类
inner.print();
}
}
Outer.Inner inner=out.new Inner(); 这样的方式也可以实例化内部类
类实质上定义的是一种数据类型,这种数据类型就是对象类型。所以
我们可以使用类名称来声明对象变量
类实例化:
public class Point {
/**
* @param args
*/
int x;
int y;
void output()
{
System.out.println(x);
System.out.println(y);
}
public static void main(String[] args) {
// TODO Auto-generated method stub
Point pt;
pt = new Point();
pt.x = 10;
pt.y = 10;
pt.output();
}
}
思路的转变:
我们通常习惯于考虑解决问题的方法,而不是考虑将问题抽象成对象再去解决它。
函数可以用修饰字符么?――― 一般什么都不用
类中 This.变量 和 变量 有没有使用上的区别?
-----区别类中的全局变量和同名的局部变量 this.x = x;
――this还可以简化构造函数的调用:必须在函数体的第一行
public class Point {
int x;
int y;
Point()
{
this(1,1);//必须在函数体的第一行
}
Point(int a,int b)
{
x=a;
y=b;
}
void output()
{
System.out.println(x);
System.out.println(y);
}
public static void main(String[] args) {
Point pt;
pt = new Point();
pt.output();
}
}
方法的重载overload:方法的名称相同,但参数类型或个数不同,才能构成方法的重载
多个构造方法:
public class Point {
int x;
int y;
Point()
{
x=5;
y=5;
}
Point(int a,int b)
{
x=a;
y=b;
}
void output()
{
System.out.println(x);
System.out.println(y);
}
public static void main(String[] args) {
Point pt;
pt = new Point();
pt.output();
Point pt2;
pt2 = new Point(6,6);
pt2.output();
}
}
new 关键字的作用
1 为对象分配内存空间
2 引起对象构造方法的调用
3 为对象返回一个引用
一个类所有的实例调用的成员方法在内存中只有一份拷贝
pt.output()
pt2.output()
output方法只有一份拷贝,而实例成员可以存在多个拷贝
static方法,可以直接使用 类名.static方法 调用
在静态方法中不能调用非静态的方法和引用非静态的成员变量。反之,则可以。
public class Point {
int x;
static void output()
{
System.out.println("333");
}
public static void main(String[] args) {
Point.output();
}
}
静态方法只属于类本省,不属于对象,静态方法也叫类方法,非静态方法叫做实例方法。
如果改动一下:
static void output()
{
System.out.println(x);
}
这样会报错,因为直接使用类名.static方法调用是没有生成对象的,没有对象那么也就没有对象成员x.的内存空间【内存模型概念,没有内存空间都是不能被调用的】。如果一定要输出x,那么就要声明为静态变量,类变量。
public class Point {
static int x = 3;
static void output()
{
System.out.println(x);
}
public static void main(String[] args) {
Point.output();
}
}
静态成员:
public class Point {
static int x;
public static void main(String[] args) {
Point pt = new Point();
Point pt2 = new Point();
pt.x=1;
pt2.x=2;
System.out.println(pt.x);
System.out.println(pt2.x);
//两个对象共享同一个静态变量,静态变量属于类本身,而不是属于对象
}
}
常量:通常大写,并推荐声明为静态。值不能被修改.声明的时候要初始化,也可以在构造函数中初始化。但是当声明是静态的常量,那么一定必须在声明的时候初始化,直接使用类名.类变量来访问的时候常量没有被赋值就是错误的。
final double PI = 3.1415926;
Extends 继承
Java不也许多继承,即是一个类不也许同时继承多个类
方法的覆盖:在子类中定义一个与父类同名,返回类型,参数类型均相同的一个方法。
当实例化子类的时候,父类的构造方法先与子类的构造方法被调用
class Person
{
int height;
Person()
{
System.out.println("Person construct");
}
}
class Fish extends Person
{
int height;
Fish()
{
System.out.println("Fish construct");
}
}
class Animal
{
Animal()
{
}
public static void main(String[] args) {
Fish fh = new Fish();
}
}
构造方法不能被继承
多态性:通过覆盖父类的方法来实现,在运行时根据传递的对象引用,来调用相应的方法。
class Person
{
int height;
Person()
{
System.out.println("Person construct");
}
void breathe()
{
System.out.println("Person breathe");
}
}
class Fish extends Person
{
int height;
Fish()
{
System.out.println("Fish construct");
}
void breathe()
{
System.out.println("Fish breathe");
}
}
class Animal
{
Animal()
{
}
static void fn(Person ps)//对象引用的传递,原本传递的父类,但是可以被子类替换
{
ps.breathe();
}
public static void main(String[] args) {
Fish fh = new Fish();
Person ps;
ps = fh;
Animal.fn(ps);
}
}
/*
Person construct
Fish construct
Fish breathe
*/
判断一个对象是否是××的实例instanceof
if(an instanceof Animal)
{
}
子类也是父类的实例
Package 主要是避免类名相同的麻烦。Java文件中package 必须位于第一行
Javac –d . Test.java -d可以自动生成package所对应的目录层次 .表示当前目录,也可以指定目录 javac –d d:\test Test.java
Java com.Test
Import java.io.File;
Import java.io.*;
在同一个包中的类可以相互引用,无需import语句
如果不import,可以这样申明对象f:java.io.File f;
批量编译javac –d . *.java
类的修饰符
类的访问说明符:public default 控制别的包,类引用
public 可以被不同包引用,java内置的包都是public
default 只能被同包中的类引用
其它修饰符:final abstract
final 最终的包,不能再派生 java.lang.string 就是final
abstract 抽象类,配合抽象方法。抽象类不能被实例化。子类要实现父抽象类的所有抽象方法,否则这个子类也要声明为抽象类。我们可以将一个没有任何抽象方法的类声明为抽象类,避免由这个类产生任何的对象。
有的可以同时使用:
public final class Test
public abstract calssTest
接口:所有的方法都是抽象方法
方法的修饰符
方法的访问说明符:public(java内置的方法都是public) protected default(只能在同包中访问) private(卧室概念,只能在同类中所访问)
protected 的通用性不能被使用是怎样的情况----不同的包只有是父子类的关系才能被访问,不是父子类关系的不同包是不能访问的。也就是有父子关系的类可以使用
其它修饰符:static final abstract native synchronized
final 不能被覆盖的类,private 或 static 修饰的方法都是 final ,子类中重写static方法,只是生成了另一个static方法,并没有覆盖父类中的static
abstract 写法: protected abstract void test(); 有抽象方法的类必须声明为抽象类。抽象类不能被实例化。子类要实现父抽象类的所有方法,否则这个子类也要声明为抽象类
接口 interface
class **(类) implements(实现) **(接口)
interface **(接口) extends(继承) **(接口)
接口的派生类必须实现接口里所有的方法,否值必须把该类声明为抽象类
派生类的方法一律不得低于public
接口中的所有的方法都是public abstract ,不能对接口中的方法使用其它修饰符
接口中的成员变量默认为public static final
接口类一般声明为public
java中允许接口的多继承,不允许其它类的多继承
允许一个类实现多个接口,一个类在继承的同时可以实现多个接口。
如何返回接口的成员
接口实例:电脑主板显卡
内部类
内部类编译后的文件名为:Outer$Inner.class
Outer.java
class Outer {
private int index=100;
class Inner
{
void print()
{
System.out.println(index);//内部类可以外部的访问private 的成员变量
}
}
void print()
{
Inner inner=new Inner();
inner.print();
}
}
Test.java
class Test {
public static void main(String[] args) {
Outer outer=new Outer();
outer.print();
}
}
内部类可以随意访问外部类的所有成员变量和方法。
访问外部类和内部类的成员变量
Outer.java
class Outer {
private int index=100;
class Inner
{
private int index=50;
void print()
{
int index=30;
System.out.println(index);//30
System.out.println(this.index);//50
System.out.println(Outer.this.index);//100
}
}
void print()
{
Inner inner=new Inner();
inner.print();
}
}
Test.java
class Test {
public static void main(String[] args) {
Outer outer=new Outer();
outer.print();
}
}
实例内部类
Outer.java
class Outer {
private int index=100;
class Inner
{
private int index=50;
void print()
{
int index=30;
System.out.println(index);
System.out.println(this.index);
System.out.println(Outer.this.index);
}
}
void print()
{
Inner inner=new Inner();
inner.print();
}
Inner getInner()//返回值是对象
{
return new Inner();
}
}
Test.java
class Test {
public static void main(String[] args) {
Outer outer=new Outer();
Outer.Inner inner=outer.getInner();//不能直接访问内部类,Inner inner=outer.getInner();是错误的写法,必须加上它的前缀外部类
inner.print();
}
}
Outer.Inner inner=out.new Inner(); 这样的方式也可以实例化内部类
- 对象知识点.rar (648.1 KB)
- 下载次数: 0
发表评论
-
jdk1.4,jdk1.5和jdk1.6的区别
2013-05-14 18:54 1172来源:http://blog.csdn.net/f ... -
Response.ContentType 详解
2013-03-13 09:45 1316不同的ContentType 会影响客户端所看到的效果.默认的 ... -
JAVA获取本地,远程macAddress
2013-02-27 13:56 939来源:http://www.2cto.com/kf/20110 ... -
java中断点续传
2013-02-22 15:38 1255转载自 http://www.ibm.com/ ... -
nio
2013-02-22 09:39 894来源http://blog.chinaunix.net ... -
使用非阻塞ServerSocketChannel、SocketChannel代替ServerSocket和Socket
2013-02-19 09:52 2534来源:http://blog.sina.com.cn/s/ ... -
java字符串编码类型获取
2012-10-05 10:11 921原创作品,允许转载,转载时请务必以超链接形式标明文章 ... -
Java网络编程总结
2012-09-29 14:42 0http://www.cnblogs.com/oubo/arc ... -
Java使用JNDI技术获取DataSource对象
2012-09-29 11:28 1174package common; imp ... -
Java并发包探秘 (二) ConcurrentHashMap
2012-09-27 10:49 922Java并发包中有很多精心设计的高并发容器。有Concur ... -
Java并发包探秘 (一) ConcurrentLinkedQueue
2012-09-27 10:47 1080Java并发包中有很多精心设计的高并发容器。有Conc ... -
集合之线程安全
2012-09-27 10:28 940Map map = Collections.synchro ... -
Collections.synchronizedMap(new LinkedHashMap())
2012-09-27 10:24 1229LinkedHashMap和LinkedHashSet是J ... -
Java栈与堆
2012-08-16 12:26 704Java栈与堆 ----对这两 ... -
Java中对象的六种可触及状态
2012-08-20 14:07 9951. 强可触及 垃圾收集器不会回收强可触及对象占据的空间 ... -
多线程 sleep()和wait()的区别
2012-08-14 10:12 985接触了一些多线程的东西,还是从java入手吧。 相信看这篇文 ... -
override与overload
2012-08-14 10:12 695重载Overload特点(两必须一可以) public boo ... -
Java中堆栈和内存分配原理
2012-08-13 09:32 762来源:http://uule.iteye.com/blog/1 ...
相关推荐
JAvaOOp06 第六章 集合框架.pdfJAvaOOp06 第六章 集合框架.pdf JAvaOOp06 第六章 集合框架.pdfJAvaOOp06 第六章 集合框架.pdf JAvaOOp06 第六章 集合框架.pdfJAvaOOp06 第六章 集合框架.pdf
javaoop javaoop阶段项目 javaoop阶段项目 javaoop阶段项目
s2 JavaOOP上机作业全部代码,仅供交流使用
javaOOP测试模拟试题。详细、多方位。
javaOOP总结资料,内容详细可供初学者参考。
你为面向对象思想而迷茫么.这个javaoop文档全面,通俗的诠释了javaoop思想.
S2-------JavaOOP全程解答S2-------JavaOOP全程解答S2-------JavaOOP全程解答S2-------JavaOOP全程解答
JavaOOp05 第五章 异常.pdf,JavaOOp05 第五章 异常.pdf JavaOOp05 第五章 异常.pdf,JavaOOp05 第五章 异常.pdf
Java OOP阶段小测试2.Java OOP阶段小测试2.
主要讲述了java oop中关于抽象与封装的理论知识。
JavaOOP内部测试机试题3.doc
该视频是关于JavaOOP(Java面向对象)的视频教程
JavaOOP学习重点 都是学习中记录总结出来的对概念理解很有帮助的
javaoop项目实现连数据库,实现数据的增删改查。并且对io流有一定的操作!
JavaOOP上机练习-Chapter2.zip
JavaOOP-pet.txt
本文件是ACCP S2B模Java oop的项目和本书总结PPT,希望各位合理利用!
JAVAOOP六到十章课后上机答案 包括上机课后示例代码所有答案
适合初学者学习,javaoop的练习,面向对象编程思想,封装继承多态的考察,集合框架的运用,接口的定义
JAVAOOP重点笔记总结.docx