Java面向对象基础

一、面向对象思想
- 1.编程语言的发展
- 2.什么是类？什么是对象？
- 3.面向对象特征
二、类与对象
- 1.类的声明
- 2.系统类库
- 3.访问控制
- 4.对象的创建和使用
三、方法
- 1.构造函数
- 2.函数的重载
- 3.可变参数
- 4.参数传递
四、包
- 1.包的概念
- 2.包的声明
- 3.包的编译运行
- 4.包的导入
五、4个关键字
- 1.static关键字
- 2.final关键字
- 3.this关键字
- 4.super关键字
六、对象数组

一、面向对象思想

1.编程语言的发展

2.什么是类？什么是对象？

类
用于描述同一类型事物的一个抽象的概念。
类中定义了这一类对象具有的静态和动态属性。
类也称为模板，提供了对象的基本框架。

对象
对象表示现实世界中某个具体的事物。
对象具有两方面的含义：
①在现实世界中：是客观世界中的一个实体。
②在计算机世界中：是一个可标识的存储区域。

3.面向对象特征

封装性：Java中，所有代码都封装在类内；
继承性：子类自动继承父类的属性和方法，继承性是面向对象程序设计语言不同于其他语言的最重要的特点；(重点)
多态性：相同的操作、过程可作用于多种类型的对象上并获得不同的结果。不同的对象，收到同一消息可以产生不同的结果，即具有不同的表现行为，这种现象称为多态性。

二、类与对象

1.类的声明

类（class）定义了一种新的数据类型，是具有相同特征（属性）和共同行为（方法）的一组对象的集合。

（1）定义类的语法格式为：
[访问符][修饰符] class 类名
{
[属性]
[方法]
}
属性定义的一般格式为：
type variableName=[initValue];

（2）属性在定义时，需要初始化。（成员变量：有默认初始化值，局部变量：必须手动赋初值。）
示例：
public int i=10;
private float f=1.0;
private boolean b=false;

（3）方法定义的一般格式为：
type methodName(param-list)
{
// 方法体
}
示例：
public int getMax(int a,int b)
{
return (a>b?a:b);
}

访问符：用于指明类、属性或方法的访问权限，可以是public、protected、private或默认；
修饰符：用于指明所定义的类的特性，可以是abstract、static或final等；
类名：指所定义类的名字，类名的命名必须符合命名规范，Java中类名通常由一个或多个有意义的单词连缀组成，每个单词的首字母大写，其他字母小写，如，PersonBase等。

2.系统类库

类库是已经实现了的标准的类的集合，用于完成基本的或者底层的功能，可以帮助开发者便捷的开发java程序。
java中的类根据功能的不同分为多个包，常用的包主要包括：
java.lang   语言核心包，自动导入。
java.awt   图形用户界面。
javax.swing   图形用户界面。
java.io   标准输入、输出类库。
java.util   工具包。
java.net   网络功能。

3.访问控制

访问控制符用于类、属性、函数的定义中以规定其访问权限。
访问控制符规定的权限分为四种，权限从小到大分别为：
–private 私有的，只有本类可以访问
–默认没有控制符时是默认访问权限，包内的类可以访问
–protected 受保护的，不同包的子类可以访问
–public 公开的，任何类都可以访问
只有public和默认访问权限可以修饰类。

4.对象的创建和使用

创建对象的语法为：
className variableName=new className(param-list);
创建对象的过程：
（1）使用new在堆里开辟空间，然后清零；
（2）显示初始化，按照定义顺序为变量赋初值；
（3）调用构造函数。
Java中对象的存储方式：占两块内存
堆里的对象
栈里的引用

public class Test1{int x=1;int y=f();int z=5;int f(){System.out.println("x="+x+",y="+y+",z="+z);//1,0,0return z;}Test1(int a, int b, int c){System.out.println ("x="+x+",y="+y+",z="+z);//1,0,5x=a;y=b; z=c;}public static void main(String[] args){Test1 t= new Test1(10,10,10);System.out.println ("x="+t.x+",y="+t.y+",z="+t.z);//10,10,10}
}

三、方法

1.构造函数

构造函数有以下特点：

名字特殊：函数名与类名相同。
格式特殊：没有返回值。
用途特殊：主要用于完成对象的初始化操作。
调用特殊：不能显示调用，由系统在创建对象时自动调用。

如果在类中没有定义任何的构造方法，则编译器将会自动加上一个不带任何参数的构造方法，即默认构造方法，该方法不存在于源程序中，但可以使用。例如Person类中不提供任何构造方法时，默认下面构造方法：public Person(){}
一旦类创建了自己的构造方法，默认的构造方法将不复存在，如果还想使用，可以显示的写出来。

2.函数的重载

重载指在一个类当中，具有同一个名字但参数不同（参数个数或类型不同）的多个函数。
编译器根据重载函数的参数来决定调用的函数，因此，重载函数的参数表一定不同，即参数的数量或类型不同。
构造函数也是函数的一种，因此构造函数也可以进行重载。

public class Person{int id;int age=20;Person(){id = 1;age = 20;}Person(int _id){id = _id;age=25;}Person(int _id,int _age){id = _id;age = _age;}
public void info(){System.out.println("my id is "+id);   }public void info(String p){System.out.println(p+" id is "+id);}public static void main(String[] args) {Person tom=new Person();Person lily=new Person(2);Person jerry=new Person(3,28);//调用对应构造函数tom.info();lily.info("beauty");}
}

函数重载不能以返回值类型的不同来进行区分。
示例：
bool f();
int f();
x=f(); //此时可根据x类型决定调用哪一个函数
f(); //此时将不能够区分。

3.可变参数

格式：只需在方法的最后一个参数的数据类型后增加3个点（…）即可。
如：public int add(int a,int…b){//…省略}
上例中b是一个可变参数，该参数可接受多个参数值，多个参数值被当做数组传入。

使用可变参数时的注意事项：
a.可变参数只能处于参数列表的最后；
b.一个方法中最多只能包含一个可变参数；
c.可变参数的本质就是一个数组，因此在调用时，既可以传入多个参数，也可以传入一个数组。

import java.io.*;
public class ChangeParamDemo{public static int add(int a,int...b){int sum=a;for(int e:b){sum+=e;}return sum;}public static void main(String[] args){System.out.println ("3+4 = "+add(3,4));System.out.println ("3+4+5 = "+add(3,4,5));System.out.println ("3+4+5+6 = "+add(3,4,5,6));int[] nums = {7,8,9,10,11,12};System.out.println ("sum = " + add(6,nums));}
}

4.参数传递

方法可以带参数，通过参数可以给方法传递数据。根据参数的使用场合，可以将参数分为“形参”和“实参”两种。
形参：声明方法时给方法定义的形式上的参数，此时形参没有具体的数值，形参前面必须有数据类型，使用格式是“方法名(形参)”；
实参：调用方法时程序给方法传递的实际数据，实参前面没有数据类型，使用格式是“对象名.方法名(实参)”。
实参和形参之间传递数值的方式有两种：
值传递（call by value）：参数的类型是基本数据类型时
引用传递（call by reference）：参数类型是引用类型时

（1）值传递

值传递是将实参的“值”传递给形参，被调方法为形参创建一份新的内存拷贝来存储实参传递过来的值，然后再对形参进行数值操作。
值传递时，实参和形参在内存中占不同的空间，当实参的值传递给形参时，两者之间将互不影响，因此形参值的改变不会影响原来实参的值。

import java.io.*;
public class ValueTransferDemo{public static void swap(int a,int b){int tmp=a;a=b;b=tmp;System.out.println (“swap方法里，a= ”+a+”;b=”+b);}public static void main(String[] args){int a=6;int b=9;System.out.println (“swap方法里，a= ”+a+”;b=”+b);swap(a,b);System.out.println (“swap方法里，a= ”+a+”;b=”+b);}
}

（2）引用传递

引用传递是将实参的“地址”传递给形参，被调方法通过传递的地址获取其指向的内存空间，从而在原来的内存空间直接进行操作。
引用传递时，实参和形参指向内存中的同一空间，因此当修改了形参的值时，实参的值也会改变。

import java.io.*;
class Mydata{public int a;public int b;}
public class RefernceTransferDemo{public static void swap(Mydata data){int tmp=data.a;data.a=data.b;data.b=tmp;System.out.println (“swap方法里，a= ”+data.a+”;b=”+data.b);}public static void main(String[] args){Mydata data=new Mydata();data.a=6;data.b=9;System.out.println (“swap方法里，a= ”+data.a+”;b=”+data.b);swap(data);System.out.println (“swap方法里，a= ”+data.a+”;b=”+data.b);}
}

四、包

1.包的概念

计算机操作系统使用文件夹或者目录来存放相关或者同类的文档，在Java编程语言中，提供了一个包的概念来组织相关的类。包在物理上就是一个文件夹，逻辑上代表一个分类概念。
Java中的基础类库就是使用包进行管理的。

2.包的声明

（1）创建包的语句是使用关键字package，而且应该是整个java文件的第一个语句。
（2）包内的类名唯一，一般使用域名的倒写。如：package com.edu.ysu；

3.包的编译运行

package com.edu.ysu;
public class PackageDemo {public static void main(String[] args) {System.out.println(“packageDemo");}
}

编译：javac -d . PackageDemo.java（编译后会自动产生文件目录.\com\edu\ysu，如果使用正常的编译命令，则需要手工把字节码.class文件放到.\com\edu\ysu目录下。）
运行：java com.edu.ysu.PackageDemo

4.包的导入

引用包中的类时，使用import语句。import语句的基本格式为import 包名.类名，其中import为关键字，包名和类名之间用圆点(.)隔开。
如导入上例中的类：
import com.edu.ysu.*；
注：这里 “ * ” 只代表com. edu.ysu包下的class文件，不包括下层包中的class文件。

五、4个关键字

1.static关键字

static可以修饰变量、方法和代码段。
修饰变量——静态变量
修饰方法——静态方法
修饰代码段——静态块

（1）静态变量

（1）静态变量在内存中存放在静态存储区，与对象的数据存放位置不同，是单独存放的。开辟后一直有效，直到程序结束。静态变量在内存中只有一份。
（2）静态变量不依赖于某个对象，而是属于类，所以访问方式特殊。引用静态变量的方法：
通过类的名称（推荐）
通过引用类的任一实例
（3）静态变量在程序加载时已初始化。
（4）静态变量实质上就是全局变量。

（2）静态方法

静态方法是类方法，调用时可以通过类名调用。
类的静态方法只能访问其他的静态成员，不能访问非静态成员。

（3）静态块

引用静态块的目的是为静态变量初始化。
静态代码段只执行一次，并且是在加载时执行。

2.final关键字

final 修饰符可应用于类、方法和变量。
final在应用于类、方法和变量时意义是不同的，但本质是一样的：final表示不可改变。
声明为final的变量不能被修改，因此也称为常量。
声明为final的方法不能被子类同名方法覆盖。
声明为final的类只能被实现一次，不能被继承。

3.this关键字

this一般用于类的方法定义中，代表调用该方法的对象。
关键字this与对象关联，用于指示当前对象。
当方法的参数或者方法中的局部变量与类的属性同名时，会产生冲突引起类的属性被屏蔽，此时需要通过“ this.属性名 ”的方式才能访问类的属性。

4.super关键字

表示当前对象的直接父类对象。
super有两种用途：
在子类的构造方法中调用父类的构造方法；
在子类方法中访问被隐藏的父类的属性或方法。
在创建子类对象时，系统可以自动调用父类无参的构造函数。
对于父类中带参数的构造函数，系统不能自动调用，只能在子类的构造函数中通过super()进行调用，此时，super()必须是在子类构造函数中的第一个执行语句。

六、对象数组

对象数组就是一个数组中的所有元素都是对象，声明对象数组与普通基本数据类型的数组一样，具体格式如下：类名[ ] 数组名 = new 类名[长度];

Java学习（二）面向对象基础相关推荐

20175212童皓桢 Java实验二-面向对象程序设计实验报告
20175212童皓桢 Java实验二-面向对象程序设计实验报告实验内容初步掌握单元测试和TDD 理解并掌握面向对象三要素:封装.继承.多态初步掌握UML建模熟悉S.O.L.I.D原则了解设 ...
invader的java学习第一天基础篇
invader的java学习第一天基础篇一.java主要历史 ①java是Sun公司的产品,09年被Oracle公司收购. ②java语言之父:詹姆士高斯林二.jdk.jre.jvm三者关系 jd ...
Java学习日记1——基础认知
Java学习日记1--基础认知学习Java阶段,如果发现不正确的描述,还请指正! 首先附上Java相关下载链接和配置教程链接 Java相关软件工具下载地址:官方下载 Java环境配置(win10配置 ...
Java学习---Day16_IO流基础篇
Java学习-Day16_IO流基础篇文件操作操作磁盘上的某一个文件或某一个文件夹,可以对他们进行创建或删除.移动.属性获取.属性设置等操作.但是,不包含读取文件的内容.拷贝文件 ps:java中 ...
Java学习笔记之基础篇
Java学习笔记之基础篇目录 Java如何体现平台的无关性? 面向对象(OO)的理解面向对象和面向过程编程的区别面向对象三大特征静态绑定和动态绑定(后期绑定) 延伸:类之间的关系组合(聚合) ...
深圳Java学习：面向对象【重点知识】
深圳Java学习:面向对象[重点知识] 在Java的学习中,面向对象应该是Java技术的重中之重,虽然在生活中没有对象可以面对,但在技术中还是要一直接触面对对象,而且不可避免.今天千锋小编对面向对象来 ...
invader的java学习第二天基础篇
invader的java学习第二天基础篇一.深入了解第一个Hello World程序 public class Hello World{ public static void main(String ...
JAVA学习之路--基础篇三
目录关于Java中从键盘输入的语句 nextxxx().next().nextLine()的区别语句 if和if else语句 Switch语句 for语句 while和do..while bre ...
Java学习07–前端基础之CSS
Java学习07–CSS基础 1.CSS介绍 1.1.发展史 css1.0 基本 css2.0 div(块)+css html与css结构分离的思想网页变简单 css2.1 浮动,定位 css3.0 ...
Java学习路线-夯实基础
Java学习路线-夯实基础第一部分:网络与操作系统第二部分:数据结构与算法第三部分:Java基础第四部分:Java设计模式第五部分:数据库第六部分:Redis 第七部分:并发与多线程第八 ...

Java学习（二）面向对象基础