1、面向对象程序设计的基本概念
过程是编程语言：程序=算法+数据
面向对象编程语言：程序=对象+消息
-
对象
对象的特征分为静态特征和动态特征，静态指对象的外观、性质、属性等，动态指对象具有的功能、行为等。
一个对象由一组属性和一组对属性进行操作的方法构成
-
类
具有相同属性和相同行为的一组对象称为类。
在面向对象程序操作中，类是一个独立的单元，它有一个类名，其内部包括成员变量，用于描述对象的属性；还包括类的成员方法，用于描述对象的行为。
面向对象的程序设计有3个特征：
- 封装性
- 继承性
- 多态性
方法重载：在一个类中，允许多个方法使用同一个名字，但方法的参数不同，完成的功能也不同
成员覆盖：子类与父类允许相同的变量名称，数据类型不同，允许相同的方法名称，但完成的功能不同
2、类
类和对象就是面向对象方法的核心概念。类是对某一类事物的描述，是抽象的、概念上的定义；对象是实际存在的该类事物的个体，因而也称作实例（instance）
-
类的声明
class person{
String name;
int age;
void talk(){
System.out.println("我是："+name+“，今年：”+age+“岁”);
}
}
-
类的定义
class colordefine{
String color=“黑色”；
void getMes(){
System.out.println("定义类");
}
public static void main(String args[]){
colordefine b=new colordefine();
System.out.println(b.coler);
b.getMes();
}
}
3、对象
-
对象的声明
Person p; //先声明一个Person类的对象p
p=new Person(); //用new关键字实例化Person的对象P
或者
Person p=new Person();
-
对象的使用
访问属性：对象名称.属性名
访问方法：对象名称.方法名（）
p.name; //访问person类中的name属性
p.age; //访问person类中的age属性
p.talk(); //调用person类中的talk()方法
-
对象的比较
有两种方式可用于对象间的比较，即==运算符与equals()方法
==运算符用于比较两个对象的内存地址是否相等，equals（）方法用于比较两个对象的内容是否一致。
//==运算符用于比较
public class game{
public static void main(String[] args) {
String str1=new String("java");
String str2=new String("java");
String str3=str2;
if(str1==str2)
{
System.out.println("str1==str2");
}else{
System.out.println("str1!=str2");
}
if(str2==str3){
System.out.println("str2==str3");
}else{
System.out.println("str2!=str3");
}
}
}
//equals方法用于对象比较
public class game{
public static void main(String[] args) {
String str1=new String("java");
String str2=new String("java");
String str3=str2;
if(str1.equals(str2)){
System.out.println("str1 equals str2");
}else{
System.out.println("str1 not equals str2");
}
if(str2.equals(str3)){
System.out.println("str2 equals str3");
}else{
System.out.println("str2 not equals str3");
}
}
}
-
对象数组的使用
两个步骤：
- 声明类类型的数组变量，并用new分配内存空间给数组
- 用new产生新的对象，并分配内存给它
Person p[];
p=new Person[3];
p[0]=new Person();
p[1]=new Person();
p[2]=new Person();
或者
Person p[]={new Person(),new Person(),new Person()};
用静态方式初始化对象数组
class Person{
String name;
int age;
public Person(){
}
public Person(String name,int age){
this.name=name;
this.age=age;
}
public String talk(){
return"我是："+this.name+"，今年："+this.age+"岁";
}
}
public class game{
public static void main(String[] args) {
Person p[]={new Person("张三",25),new Person("李四",30),new Person("王五",35)};
for(int i=0;i<p.length;i++){
System.out.println(p[i].talk());
}
}
}
4、类的属性
类的基本组成部分包含属性和方法，类的属性也称成员变量。
-
属性的定义
类的属性定义规则
1、类的属性是变量
2、类的属性的类型可以是基本类型也可以是 引用类型
3、类的属性的命名规则，首单词的首字母小写，其余单词的首字母大写
类变量和成员变量的区别在于：类变量就是static修饰的变量，它们被类的实例所共享，就是说一个实例
改变了这个值，其余的实例也会受到影响；成员变量则是实例所私有的，只有实例本身可以改变它的值
```
- ###属性的使用
```java
public class game{
static String a="string-a";
static String b;
String c="string-c";
String d;
static{
printStatic("before static");
b="string-b";
printStatic("after static");
}
public static void printStatic(String title){
System.out.println("---------"+title+"---------");
System.out.println("a=\""+a+"\"");
System.out.println("b=\""+b+"\"");
}
public game(){
print("before constructor");
d="string-d";
print("after constructor");
}
public void print(String title){
System.out.println("---------"+title+"---------");
System.out.println("a=\""+a+"\"");
System.out.println("b=\""+b+"\"");
System.out.println("c=\""+c+"\"");
System.out.println("d=\""+d+"\"");
}
public static void main(String[] args){
new game();
}
}
```
```java
分析：
java 类属性和对象属性的初始化顺序如下：
1、类属性（静态变量）定义是的初始化，如上述中的static String a=“string-a"
2、static块中的初始化代码，如上述中的static{}中的b="string-b"
3、对象属性（非静态变量）定义是的初始化，如上述中的String c="string-c"
4、构造方法（函数）中的初始化代码，如上述构造方法中的d="string-d"
```
##5、类的方法
类的方法是类的任一个特定实例能够调用的方法，作用范围是整个类，而不是类的某个特定实例。类方法也称作静态方法，在类中定义的方法叫做该类的成员。
- ###方法的定义
type name(参数列表）{
//方法主题
}
type 指定了由方法返回的数据类型。它可以是任意有效的类型，包括创建而的类类型。如果方法没有返回值，则其返回类型必须是void。方法的名字有name指定，这个名字可以是除了那些在当前作用域中已经使用的标识符之外的人以合法标识符。
- ###方法的使用
```java
public class methoddemo{
int a =12345679,b=81;
public void times(int i,int j ){
System.out.println(i*j);
}
public static void main(String[] agrs){
methoddemo m=new methoddemo();
m.times(m.a, m.b);
}
```
- ###构造方法
在Java程序里，构造方法所完成的主要工作是帮助新创建的对象赋处置。可将构造方法视为一种特殊的方法，它的定义方式与普通方法类似
class 类名称
{
访问权限 类名称（类型1 参数1，类型2 参数2，...)
{
程序语句；
...//构造方法没有返回值
}
}
#####使用构造方法的时候需要注意：
- 它具有与类相同的名称。
- 它没有返回值。
构造方法除了没有返回值，且名称必须与类的名称相同之外，它的调用机制也与一般的方法不同。一般的方法是在需要时才调用，而构造方法则是在创建对象时自动调用，并执行构造方法的内容。因此，构造方法无需在程序中直接调用，而是在对象产生是自动执行。
```java
class Person{
public Person(){ //Person类的构造函数
System.out.println("public Person()");
}
}
public class game{
public static void main(String[] agrs){
Person p=new Person();
}
}
```
- ##构造方法的重载
```java
class Person{
private String name;
private int age;
public Person(String n,int a){
name=n;
age=a;
System.out.println("public Person(String n,int a)");
}
public String talk(){
return "我是:"+name+"，今年："+age+"岁";
}
}
public class game{
public static void main(String[] args){
Person p=new Person("张三",25);
System.out.println(p.talk());
}
}
```
由上述程序可以发现，构造方法的基本作用就是对类中的属性初始化，在程序产生类的实例对象时，将需要的参数由构造方法传入，之后再由构造方法为其内部的属性进行初始化。
- ###构造方法的私有
```java
public class game{
private game(){
System.out.println("private game");
}
public static void main(String[] agrs){
new game();
}
}
```
```java
class Person{
String name;
//在本类声明一个Person对象p,注意此对象用final标记，表示不能再重新实例化
private static final Person p=new Person();
private Person(){
name="张三";
}
public static Person getP(){
return p;
}
}
public class game{
public static void main(String[] agrs){
//声明一个Person类的对象
Person p=null;
p=Person.getP();
System.out.println(p.name);
}
}
```
- ###在类内部调用方法
```java
class Person{
private String name ;
private int age;
private void talk(){
System.out.println("我是："+name+"，今年"+age+"岁");
}
public void say(){
talk();
}
public void setName(String str){
name=str;
}
public void setAge(int a){
if(a>0)
age=a;
}
public String getName(){
return name;
}
public int getAge(){
return age;
}
}
public class game{
public static void main(String[] agrs){
//声明并实例化一个Person对象P
Person p=new Person();
//给p中的属性赋值
p.setName("张三");
//在这里将p对象中的年龄属性赋值为30岁
p.setAge(30);
//调用Person类中的say()方法
p.say();
}
}
```