`

java oop

阅读更多
对象一般都有两个特征:状态和行为

类实质上定义的是一种数据类型,这种数据类型就是对象类型。所以
我们可以使用类名称来声明对象变量



类实例化:


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();  这样的方式也可以实例化内部类

分享到:
评论

相关推荐

    JavaOOP_第1章上机练习.zip

    在"JavaOOP_第1章上机练习.zip"这个压缩包中,我们可以预见到它包含了关于Java OOP的初步学习材料,特别是针对初学者的上机实践练习。 在Java OOP中,有四个核心概念:封装、继承、多态和抽象。这些概念是理解Java ...

    s2 JavaOOP上机作业全部代码

    在这个“s2 JavaOOP上机作业全部代码”压缩包中,包含了学生在学习Java OOP时可能遇到的各种练习和问题的解决方案。这些代码示例旨在帮助学生深入理解类、对象、继承、封装、多态等核心OOP概念。 首先,让我们详细...

    javaoop文档+阅读器

    这份“javaoop文档+阅读器”资料包,旨在帮助你理解和掌握面向对象的思想,通过深入浅出的方式解析Java OOP的关键概念。 首先,让我们了解一下面向对象的基本概念。面向对象编程是一种基于“对象”的编程方式,它将...

    JAVAOOP所有内测题目

    以下是一些可能涵盖在"JAVAOOP所有内测题目"中的关键知识点: 1. **类与对象**:Java中的所有数据结构都基于类,而类是对象的蓝图。理解如何定义类,包括属性(成员变量)和方法(成员函数),以及如何创建和使用...

    javaoop阶段项目

    在这个“javaoop阶段项目”中,我们很可能会涉及以下关键知识点: 1. 类与对象:在Java中,类是创建对象的蓝图,它定义了对象的属性和行为。对象则是类的实例,具有类定义的特性和功能。通过`class`关键字我们定义...

    JavaOOP_第2章上机练习.zip

    在本压缩包“JavaOOP_第2章上机练习.zip”中,主要涉及的是Java面向对象编程(Object-Oriented Programming,简称OOP)的相关知识。Java OOP是Java编程语言的核心特性,它允许我们将复杂的程序设计分解为一系列相互...

    JAVAOOP六到十章课后上机答案

    Java面向对象编程(Java OOP)是Java编程的核心概念,它基于类和对象,强调封装、继承和多态性这三大特性。本压缩包包含了Java OOP六到十章课后上机作业的答案,旨在帮助学习者巩固和深化对这些章节的理解。 第六章...

    JAVAOOP课本一到五章全套练习答案

    每个压缩包文件(如JavaOOP01至JavaOOP05)很可能对应每章的一个或多个练习题目,包括源代码和解题分析。学习者可以通过查看这些示例代码,理解并模仿编程思路,以提高自己的编程技能。在实际练习中,建议先尝试自己...

    Javaoop学习总结

    Java OOP(面向对象编程)是Java编程的核心概念,它主要包含了三个主要特征:封装、继承和多态。这些特性使得代码更加模块化,可维护性更强,也更易于复用。 封装是面向对象编程的基础,它允许我们将数据和操作数据...

    Java OOP学习笔记

    Java面向对象编程(Object-Oriented Programming,简称OOP)是Java编程的核心,它通过封装、继承和多态三大特性来构建高效的代码结构。在Java OOP中,封装是首要原则,它允许我们隐藏实现细节,只对外提供必要的接口...

    JavaOOP学习重点

    Java面向对象编程(Object-Oriented Programming,简称OOP)是Java编程的核心,它通过类、对象、封装、继承、多态等概念构建程序。在Java OOP学习中,掌握这些概念并能灵活运用至关重要。 1. **类与对象**: 类是...

    宠物管理系统及Java OOP总结PPT

    宠物管理系统及Java面向对象编程(OOP)是一个典型的IT领域课题,它涵盖了软件开发中的核心概念和技术。在Java OOP中,我们通过类、对象、继承、封装和多态等核心概念来构建可复用、模块化且易于维护的代码。 首先...

    java oop 面向对象( 门禁系统)

    面向对象编程(Object-Oriented Programming,简称OOP)是Java语言的核心概念,它是一种将现实世界中的事物抽象为程序中的对象的编程范式。在Java OOP中,我们通过类(Class)来定义对象(Object)的结构和行为,...

    JavaOOP上机练习-Chapter2.zip

    在这个"JavaOOP上机练习-Chapter2.zip"文件中,我们很可能是继续深入学习这些关键概念。 首先,我们要理解类与对象。类是Java中的蓝图,它定义了一组具有相同属性和行为的对象。对象是类的实例,它们包含了类定义的...

    北大青鸟javaOOP多态Ch03作业全集.rar

    "北大青鸟javaOOP多态Ch03作业全集.rar"这个压缩包文件很显然是针对学习者提供的一系列关于Java多态性的练习和案例,帮助学生深入理解并掌握这一核心技能。 多态性是面向对象三大特性之一,另外两个是封装和继承。...

    Java oop 聂书志 案例开发源代码

    Java面向对象编程(Object-Oriented Programming,简称OOP)是一种强大的编程范式,它将程序设计中的实体抽象为类,通过类的实例化来创建对象,并通过对象之间的交互实现功能。聂书志的Java OOP案例开发源代码提供了...

    javaoop项目完成数据的曾删改查功能

    在Java OOP(面向对象编程)项目中,数据的增删改查(CRUD:Create, Read, Update, Delete)是常见的数据库操作,这通常涉及到Java与数据库的连接、SQL语句的执行以及数据流的处理。以下是这个项目中可能涉及的一些...

    JavaOOP内部测试机试题2.doc

    JavaOOP内部测试机试题2.doc 本资源主要关注Java面向对象编程(OOP)思想的应用,涵盖了封装、继承、多态、集合框架和接口的定义等关键知识点。通过完成一个中超联赛管理系统的开发,学生可以熟悉Java语言的使用和...

    Java oop面向对象15章资料

    在Java编程语言中,面向对象编程(Object-Oriented Programming, OOP)是核心概念之一,它基于类和对象的概念,使程序设计更加模块化、易于理解和维护。本章资料聚焦于Java OOP的深入实践,通过具体的项目案例来帮助...

Global site tag (gtag.js) - Google Analytics