Java面向对象

面向对象的基本概念

一. 类

1.什么是类：

答:类是一组对象的分类,在Java中可以看成类别的划分

2.类如何创建：

答:

public class 类名{

//属性:静态描述

//方法动态描述:

}

 

二. 对象

1.什么是对象：

答:对象是对类的具体表现,具体实现!

2.如何产生一个对象：

答:new

3.匿名对象：没有名字的对象，匿名对象其实就是定义对象的简写格式；

使用情况：1>当对象对方法仅调用一次时，可以使用匿名对象进行简写；

2>匿名对象可以作为实际参数进行参数传递；（形参会引用这个对象）

 

三. 属性

1.什么是属性：

答:对类的静态描述!

2.如何定义一个属性：

答:在类中声明一个变量就行!

3.如何在对象中使用属性：

答:对象名.属性名

 

四. 方法

1.什么是方法：

答:对类的动态描述!

2.如何定义一个方法：

作用域  返回类型  方法名(形式参数列表){

方法体;

}

1> 方法名:遵循变量命名规则,规范要求:动词,首字母小写,驼峰

2> 作用域:显示(可见)级别,绝大多数都是public

3> 返回类型:无返回(void),有返回(type)

4> 形式参数列表:这个方法被调用需要传递什么参数

4.如何调用方法

答:对象名.方法名(实际参数列表);

 

五：构造器（构造方法）

1.作用：初始化属性，在创建对象时一同执行；

2.语法：

作用域 类名 （形式参数列表）{

}

3.分类：

1>隐式构造器：系统给每个类都创建一个无参的构造器；（数值类型默认值为0，boolean型默认值为false，其余值为null）

2>显式构造器：自定义的构造器，当程序员书写显示构造器时，隐式构造器消失；

 

无参数构造器；有参数构造器。

 

六：类和对象

1.类是对象的抽象,对象是类的具体实现;

2.类是一个概念性的东西,而对象是一个实体,实实在在存在的;

3.类有属性和方法去描述,对象也有属性和方法,区别在于:类看中的是声明,对象看中的实现(值)。

 

七：成员变量和局部变量

1.成员变量：就是在类中定义的变量（属性），整个类中有效，成员变量存在于堆内存中的对象中，随着对象的创建而存在，随着对象的消失而消失；

2.局部变量：在方法，块，程序体中定义的变量，局部变量存在于栈内存中的方法中，局部变量随着所属区域的执行而存在，随着所属区域的结束而释放；局部代码块的应用：可以定义局部变量的生命周期；

3.不同点：成员变量是在new是初始化，局部变量是在使用前初始化（没有赋值的局部变量是不可以使用的）；两者定义范围不同，作用域也不同，成员变量都有初始化值，局部变量没有初始化值；

4.优先级：当成员变量和局部变量重名时，以局部变量为主，如果要使用成员变量：this（当前类的对象）。

 

八：汇总

1.调用问题：

1>自身类中的方法（成员方法）或者方法（成员方法）时，可以直接调用也可以通过“this.名字”调用；

2>其他类中的方法（成员方法调）用别人类中属性（成员变量）和方法（成员方法）时，通过对象名调用；

2.站位

 package Pro_0624;



public class Test {

public static void main(String[] args) {

//产生一个学生对象

//类 对象名 =new 类（构造器）；

//产生了一个学生类的一个对象，对象名：s1

Student s1=new Student();

s1.stuNo=1;//给s1对象的编号赋予1

s1.stuName="张三";

s1.stuAge=27;

s1.stuSex="女";

System.out.println(s1.stuNo);

System.out.println(s1.stuName);

System.out.println(s1.stuAge);

System.out.println(s1.stuSex);

s1.eat();

s1.sleep();

//在教室中任意找一个类声明，然后产生一个对象去表述它

Room s2=new Room();

s2.light="日光灯";

s2.number_light=5;

s2.volume=100.32f;

s2.windos="有四块玻璃";

s2.room();

}



}

package Pro_0624;



public class Room {

String windos;

String light;

int number_light;

float volume;

public void room() {

System.out.println(number_light);

System.out.println(windos);

System.out.println(light);

System.out.println(volume);

}



}

package Pro_0624;



//在一个java文件中，可以有多个类，但一个类只有一个public，这个public类必须和文件名相同

public class DemoA {

public static void main(String[] args) {

//实名对象

Student s1=new Student();

//匿名对象

new Student().sleep();



}



}

class DemoB{

 

}

class DemoC{

 

}

 

package Pro_0624;



public class MethodDemoA {

public void methodA() {

System.out.println("你好");

}

//这个方法必须在方法体最后一行，返回一个int类型的值

public int methodB() {

int a=18;

return a;

}

public static void main(String[] args) {

//方法的调用者

MethodDemoA mad=new MethodDemoA();//首先产生一个对象

int a=mad.methodB();//调用这个方法会得到int 类型的值

System.out.println(a);

}



}

 

package Pro_0624;

//创建一个类

public class Student {

//他是什么？属性：静态描述

int stuNo;

String stuName;

String stuSex;

int stuAge;

//属性越多，描述越清晰

//他能做什么？方法：动态描述

public void sleep(){

System.out.println(stuName+"准备睡觉");

}

public void study(){

System.out.println(stuName+"准备学习");

}

public void eat(){

System.out.println(stuName+"准备吃饭");

}

//方法越多，描述越清晰



}

面向对象：三个特性

 

一.封装

1.概念：将属性私有化，提供了公开的接口访问这些私有属性。

2.实现：

1>将属性私有化（private）；

2>提供两个公开方法（负责获取内容：get，负责修改内容：set）访问私有属性；

3.注意及好处：

1>提升了代码的安全性，提示了代码的隐私性；

2>命名规范****：Java是一种区分字母的大小写(case-sensitive)的语言,下面为Java语言中命名规范。

<1>Package(包)的命名:Package的名字应该都是由一个小写单词组成,例如net.ebseries.modules；

<2>Class(类)的命名:Class的名字首字母大写,通常由多个单词合成一个类名，要求每个单词的首字母也要大写,例如：DataFile或InfoParser；

<3>变量的命名:变量的名字可大小写混用，但首字符应小写。词由大写字母分隔，限制用下划线，限制使用美元符（&#36;），因为这个字符对内部类有特殊的含义。如：inputFileSize；

<4> Interface(接口)的命名:与Class的命名类似；

<5>Static Final 变量（相当于常量）的命名Static Final 变量的名字应该都大写，并且指出完整含义，例如：final MAXUPLOADFILESIZE=1024；

<6>方法的命名方法名的第一个单词应该是动词，大小写可混用，但首字母应小写。在每个方法名内，大写字母将词分隔并限制使用下划线。参数的名字必须和变量的命名规范一致。使用有意义的参数命名，如果可能的话，使用和要赋值的字段一样的名字：setCounter(int size){   this.size = size;   } ；

<7> 数组的命名:数组应该总是用下面的方式来命名：byte[] buffer;而不是：byte buffer[](习惯性问题而已)；

总结：尽量使用完整的英文描述符、采用适用于相关领域的术语、采用大小写混合使名字可读、尽量少用缩写，但如果用了，要明智地使 用，且在整个工程中统一、避免使用长的名字（小于 15 个字母是个好主意）、避免使用类似的名字，或者仅仅是大小写不同的名字、避免使用下划线（除静态常除外）；

 

示例：有一个图书信息：

图书的ISBN

图书的名字

总页数（1~1000）

作者

售价1~100

出版社

 

二.继承

1.概念：子类继承父类的一般特性（非私有），以及自身的属性；

2.实现：

1>书写父类：书写父类的属性和方法

2>书写子类，需要子类继承父类extends

语法：

public class 子类 extends 父类

子类可以继承非私有的属性和方法

子类中可以书写自己的属性和认为较好的方法，这些属性和方法跟父类没有任何关系

如果子类对父类的某些方法的实现不是很满意，可以重写方法内容（实现）——方法的重写

3.注意事项：

1>java是单继承效果，也就是说一个子类只能继承一个父类;

2> java中有一个类（object），他是所有类的直接或者间接父类，也叫做祖先类;

3>子类定义对象时，先调用父类的构造器。在子类未指明调用哪个构造器时默认调用父类的无参构造，如果没有定义（或被有参构造覆盖），则编译时会报错(故注意无参构造的定义)。

4>指定调用父类构造：super（实参）；（实参对应形参列表） //且必须放在子类构造器的第一行。

 

三.多态

1.概念：一个事物具有多种形态的特征，多态也是面向对象核心思想，如果一个语言不支持多态，那它就不是面向对象语言，如果支持封装和继承那只是基于对象语言；

2.实现：

1>方法的重写：子类重写父类的实现过程，这是一个垂直层次关系；

2>方法的重载：在同一个类中具有多个形同名称的方法，但其参数列表不同，是一个水平关系；

3.注意：

1>重写和重载的区别：

重写是一个垂直关系，它是子类重写父类的方法，要求结构相同，实现过程不同；重载是一个水平结构，它们之间参数不同；

2>在形参声明过程中，一般会声明的范围比较大，原因是声明的范围比较大，就可以传递父类，也可以传递子类，通用性较强；

 

四：三个方法修饰符：

1.static 静态：

1>概念：静态的，代表被修饰的内容会被在类加载的时候，内存加载它；

2>区域：

<1>属性：如果修饰属性，这个属性就依附于类存在，也就是说，当类加载时，这个属性就被创建了，这时候，这个属性就叫做：静态（类）变量；其调用方法为：类名.静态对象 或者 对象名.静态对象；（成员变量与静态变量的区别：成员变量只有在对象的生命周期中才存在，而静态变量在类加载入内存时就存在）

<2>方法：如果修饰方法，这个方法就依附于类存在，也就是说，当类加载时，这个方法就被创建了，这时候，这个方法就叫做：静态（类）方法；

<3>块：在类中书写的一段程序体，它会在类被加载时，依次执行，并且只执行一次；不可被手动调用；

3>注意事项：

<1>静态的 不能直接调用 成员的（静态的 肯定比 成员加载（创建）的早，导致静态的 创建时成员的 还未创建）；例如：

Demo{
    int a; //成员的
    static int c=0;
    public static void b(){ //静态方法
        System.out.println(a); //出错
            ----------------------------
        Demo z = new Demo();
        System.out.println(z.a); //不出错
    }
}

<2>成员的可以直接调用静态的；

<3>块在执行的时候是有顺序的，只能执行在它之前定义的内容；

<4>静态的可以直接调用静态的（包括main方法）；

 

 

四：四个访问修饰符：

访问权限	类	包	子类	其他包	备注
public	yes	yes	yes	yes	对任何人都是可用的
protect	yes	yes	yes	no	继承的类可以访问以及和private一样的 权限
default	yes	yes	no	no
private	yes	no	no	no

修饰符：

 

final ：

当其修饰一个属性时，必须赋值，因构造器是不会给其赋值。

 

修饰类：代表这个类是不能被继承的；是最终类

修饰属性：代表这个属性是不能被修改的；是最终属性；

修饰方法：代表这个方法不能被重写；是最终方法；

 

 

变量：值可以发生改变的量

常量：值不能发生改变的量 5 9 9.1 张三 男

常量的命名规则：全大写 名词

public static final String USER_NAME = "李四"；

 

abstract：抽象的

修饰方法和类；

修饰方法：方法只有定义没有实现，和final关键字冲突；

修饰类：当一个类中有一个方法被abstract修饰时，这个类也要被abstract修饰；这个类是抽象类；（当类中没有抽象函数时也可以用abstract修饰）

方法的定义：

 

抽象类不能被new

如果一个子类继承了一个抽象类，就要实现所有的抽象方法，否则这个子类也被定义成抽象类；

 

interface：接口

Java：单一继承；

通过接口：实现多继承；

 

接口的声明语法格式如下：

[可见度] interface 接口名称 [extends 其他的类名] {

// 声明变量

// 抽象方法

}

接口特性：

1.接口中每一个方法也是隐式抽象的,接口中的方法会被隐式的指定为 public abstract（只能是 public abstract，其他修饰符都会报错）在定义方法时abstract可以加上，也可以省略，但实质都是抽象的；

2.接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量（并且只能是 public，用 private 修饰会报编译错误），实质上它是一个常量，故必须赋初值（一般来讲常量都喜欢定义在接口中）；

3.接口中的方法是不能在接口中实现的，只能由实现接口的类来实现接口中的方法；

4.接口也可以继承其他接口，继承原则同类；

5.接口不能被new，接口中没有构造器；

 

例如：pc卡槽：声卡，网卡……

接口的实现：

当类实现接口的时候，类要实现接口中所有的方法。否则，类必须声明为抽象的类。

类使用implements关键字实现接口。在类声明中，Implements关键字放在class声明后面。

实现一个接口的语法，可以使用这个公式：

[类的定义] implements 接口名称[, 其他接口名称, 其他接口名称..., ...] ...

 

一个类实现了多个接口时，这个类的对象属于各个接口的类型

声明对象时：等号右边

 

注意事项：

1.一个Java文件中只能有一个public类，且与文件名相同

2.Static，abstract，final：

Static可以和final同时使用，其他的都不能两两同时使用。

3.两种给属性赋值的方法：构造器，set函数。

4.如果定义对象时，声明的是父类，new的是子类，则可以调用的方法为父类中声明了的方法，但实现时用的是子类中的方法实现；