面向对象简介
计算机编程语言的发展是一个不断演化进步的过程，从机器语言提升为汇编语言，再到各种结构化高级语言，再次升华为支持面向对象技术的面向对象程序设计语言。面向对象程序设计（英文简写为OOP）是目前为止最为接近人类思维的计算机语言之一，是当今主流程序的设计典范。面向对象程序设计在20世纪60年代末就已出现了，但是到了90年代才有了显著发展。
对面向对象的理解
1）面向对象是相对面向过程而言的，且基于面向过程的。
2）面向对象是一种思想。
3）面向对象将功能封装进对象中，强调了具备功能的对象，主体是对象，将过程简化
4）在实际开发中，以对象为核心，先明确好对象，在实现具体功能，或者可是使用已有的对象。
5）面向对象的三个特征：封装性，继承性，多态性。
封装：封装是一种信息隐蔽技术，就是把属性私有化，提供公共的方法访问私有对象
继承：继承是面向对象程序设计中的重要机制，并且是提高软件开发效率的重要手段。
多态：多态是面向对象程序设计的又一重要特征。简单的说就是“一种定义，多种实现”，同一类事物表现出的多种形态。
类与对象的关系
1、类（class）：可以理解为是构造对象的一个蓝图或者模板，是抽象的概念；反过来说，对象是以类为模型创造的具体实例，是对类的一种具体化、形象化。
类：对生活中事物的描述
对象：对类的具体实现，是实实在在存在的实体。
2、例如：汽车的设计
类：指的是汽车的设计图纸
对象：指实际生产出来的汽车。
创建和使用对象
public class 成员变量和成员方法 {
public static void main(String[] args) {
/*
* 创建对象并使用
* 格式：类名 对象名 = new 类名();
* 使用成员变量：对象名.变量;
* 使用成员方法：对象名.方法名();
*/
Student s = new Student(); //创建对象 ,创建对象在最后有小括号
//String name = s.name; //获取对象的属性(成员变量)
//int age = s.age;
//char gender = s.gender;
s.name = "张三"; //获取对象中的属性并赋值,调用属性的时候后面没有括号
s.age = 23;
s.gender = '男';
s.study(); //获取对象的行为(成员方法)
s.sleep(); //调用方法的时候后面有括号
s.name = "李四";
s.study();
}
}
class Student {
/*
* 属性:姓名,年龄,性别(成员变量)
* 行为:学习,睡觉(成员方法)
*/
String name ;
int age ; //成员变量 ，定义在类中方法外
char gender ;
public void study(int x) { //局部变量，定义在方法上
int age = 30; //局部变量 ，定义在方法中
System.out.println(age); //这里输出30 因为在Java中有就近原则
System.out.println(name + "在学习");
}
public void sleep() {
System.out.println(name + "在睡觉");
}
}成员变量与局部变量
在类中的不同位置定义变量，作用范围是不同的，下面简单区分一下，两种变量的不同：
1）作用范围：
a.成员变量：作用于整个类中
b.局部变量：作用于函数中，或者作用于语句块中。
2）在内存中的位置：
a.成员变量：在堆内存中，因为对象的存在才在内存中存在。
b.局部变量：在栈内存中，随着函数的结束而消亡
3）初始化方式：
a.成员变量：随着类的初始化而初始化，在堆内存中被加载，有默认值，可直接参与运算
b.局部变量：随着方法的加载而加载进栈内存中，无初始化值，必须被初始化才能参与运算
4）在类中的位置不同：
a.成员变量：在类中方法外
b.局部变量：在方法定义中或者方法声明上
注意事项：
局部变量名称可以和成员变量名称一样，在方法中使用的时候，采用的是就近原则。
匿名对象
1、简述：所谓匿名对象，就是创建的对象没有名字，直接使用。
2、使用方式：
1）使用方式一：当对对象的方法只调用一次时，可以使用匿名对象来完成，这样写比较简化。如果对一个对象进行多个成员调用，必须给这个对象起个名字
2）使用方式二：可以讲匿名对象作为实际参数进行传递，从而可以不用在main方法中创建一个变量，提高了编程效率，减少了代码书写。但是这个对象实体在方法结束后，垃圾回收机制会将其作为垃圾回收。而非匿名对象则不同，当不使用了，会在某一时刻被回收，或是随着主函数的结束而被回收。
封装
概述
1、定义：封装是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
2、好处：
a.将变化隔离
b.便于使用
c.提高重用性
d.提高安全性
3、原则：
a.将不需要对外提供的内容隐藏起来
b.把属性都隐藏，提供公共方法对其访问
4、说明：
a.私有仅仅是封装的一种表现形式，如包也是一种封装形式
b.之所以对外提供访问方式，就是因为可以在访问方式中加入逻辑判断等语句，对访问的数据进行操作，提高了代码的健壮性。
private 关键字
1、private是一个权限修饰符
2、用于修饰成员（成员变量和成员函数）
3、被私有化的成员只在本类中有效。
4、常用之一：将成员变量私有化，对外提供对应的set和get 方法对其进行访问，提高了对数据访问的安全性。
5、当把类中的所有构造函数私有化后，代表着该类是不能创建对象的，因为对象不能进行初始化操作的。
class Person {
private String name;
private int age;
//变量名要求见名只意
public void setName(String name) {
this.name = name; //this代表当前对象的引用
} //局部变量绝对不能用对象.调用
public String getName() {
return name;
}
public void setAge(int a) {
age = a;
}
public int getAge() {
return age;
}
public void print() {
System.out.println("print方法中的:" + this);
method();
}
public void method() {
System.out.println("method");
}
/*
this可以用来区分成员变量和局部变量重名,用this.调用的是成员变量
this可以调用成员方法
*/
}成员访问权限比较
权限大小
成员修饰符 public protected default(默认) private
同一个类中 OK OK OK OK
同一个包中 OK OK OK NO
子类访问 OK OK NO NO
不同包中 OK NO NO NO
public类与源文件名
一个编译单元（个人理解为执行main函数所调用到的所有文件）中只能有一个public类，且这个类的文件名必须要和其类名相同，包括大小写也必须一样。
原因：
1、一个编译单元只能有一个public类的原因：
第一、public的意思是所有类都能访问，包括包以外的类。public是作为这个编译单元的公开接口存在的。
第二、java程序的入口是main方法，所以被定为public的这个类一定是main方法的类，且这个类的名称要和文件名一直，因为虚拟机是要开始找main方法这个入口的。
第三、你可以根据需要，添加任意辅助功能的public权限的类，但是如果这个编译单元（注意是编译单元）里面有两个或以上public类的话，那么编译器就会报错。
建议：
第一、不要在一个源文件中写多个类。在标准的java代码编写时，无论代码量是多少，最好一个源文件只有一个类或接口（即使是接口也要如此），因为java是面向对象的语言，每个类都是抽象的结果，所以每个类要单独写在一个源文件里。
第二、只要要有一个是public类，虽然可以在编译单元中没有public类，即没有公开的接口，可在同一个包中访问，但是这样就将这个包都封闭了，是没意义的。如果没public，就可以随意给文件起名，可以不和类名相同。
2、被public修饰的类与文件名必须同名的原因：
第一、java是被编译执行的，它在运行时并不是将你写的所有类都先加载一遍的，而是当遇到import或使用到了其他类的时候，才会去在文件目录中找相应的class文件的。
第二、对于一个public类。上面也说了，是可以被项目中的任何一个类引用的，只需通过import导入即可。既然是作为虚拟机入口的main函数要用public修饰而成为一个公共接口，那么将类名和文件名一一对应就可以方便虚拟机在相应的路径（包名）中找到相关的信息；但是你如果不这么做，虚拟机很难去找，开销也会跟着增大的。
简单总结：
public作为一个公共接口（此接口非interface这个接口），修饰作为虚拟机入口的main函数，就是为了方便虚拟机找到相应的类，从而节省开销。
main函数：
我们刚开始接触java的时候就是用到了main函数，那么主函数是什么呢？在此分别对主函数的各个关键字及修饰符进行简单说明：
public static void main(String [] args){….}
1、主函数：是一个特殊的函数，作为程序的入口，可以被JVM识别并调用，它的格式是固定的。
2、主函数的定义：
1）public ：代表着该函数的访问权限是最大的。
2）static ：代表着主函数随着类的加载就已经存在了，一边执行函数中的代码。
3）void ：主函数没有具体的返回值，只是作为执行程序的入口。
4）main ：不是关键字，和其他的函数名类似，只不过别定义为一个特殊的单词，可以被JVM识别。
(String [] args))：函数的参数，参数类型是一个String类数组，元素为字符串。字符串类类型是数组，args是一个变量名，是约定俗成的，早期被写成arguments；如果改写成其他名称也是可以的。
3、注意：
可以重载主函数，但是虚拟机只识别固定格式的主函数，即 public static void main(String [] args){….}。
构造函数
方法名与类名相同(大小也要与类名一致)
没有返回值类型，连void都没有
没有具体的返回值
一创建对象就执行，不用调用
注意事项：
1.如果在一个类中没有定义构造方法,系统会默认给一个空参的构造方法
格式是:public 类名(Student)(){}
2,如果定义有参构造函数,没有定义空参构造函数,系统不会默认再给空参构造函数
3,空参什么用,有参什么用?
a 有参的构造函数就是为了给对象中的属性进行初始化用的
b 空参在不需要给属性进行初始化,但是还要创建对象的时候使用
4,定义了有参构造函数,要不要再定义空参的呢?
建议把空参的加上,为了创建对象,调用成员使用
public static void main(String[] args) {
//Student s = new Student();
Student2 s2 = new Student2("李四",24);
s2 = new Student2("李五",25); //新对象将原来对象的地址值覆盖,原对象变成垃圾
}
}
class Student2 {
private String name ;
private int age;
//无参构造创建对象时使用
public Student2() { //构造方法给成员变量进行初始化
//name = "zhangsan";
//age = 23;
super();
}
public Student2(String name, int age) {//有参构造，给对象中的属性进行初始化使用
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
/*
构造方法和setXxx方法的区别
1,构造方法是用来给对象中的属性进行初始化的
2,setXxx是用来修改属性值的,在原对象的基础上
*/
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
this关键字：
1、this：表面上，是用于区分局部变量和成员变量同名的情况。即this代表着当前对象的引用。
2、this的用法：
a.用于区分同名变量的情况。当局部已经定义了变量，当需要找成员中的变量，且变量名相同时，为了区分局部变量和成员变量的相同变量名，可以使用this加以区分。
b.用于构造函数间的调用。
3、特点：
1）this代表了本类的对象，即代表了它所在函数所属对象的引用，也就是说，哪个对象调用这个函数，this就代表哪个对象。
2）一般情况下，this都是被省略的，需要使用的时候才需加上。
4、this应用：
当定义类中的功能时，该函数内部要用到调用该函数的对象时，这时用this来表示调用这个函数的对象。
只要本类功能内部使用了本类对象，都用this表示。
5、在构造函数中的应用：
this语句：用于构造函数之间的互相引用。且只能放在构造函数的第一行，否则编译失败。
原因：初始化的动作要先执行，因为自身的特性要先具备；如果初始化中还有初始化，要限制性更细节的操作，然后再执行自己所需求的初始化。
注意：不允许两个构造函数间相互调用this语句，否则会出现死循环。
一般函数中不能定义this语句。
静态
static关键字的特点
a:随着类的加载而加载
b:优先于对象存在
c:被类的所有对象共享
d:可以通过类名调用，其实它本身也可以通过对象名调用
static的注意事项
a:在静态方法中是没有this关键字的
静态是随着类的加载而加载，this是随着对象的创建而存在。
静态比对象先存在。
b:静态方法只能访问静态的成员变量和静态的成员方法
静态方法：
成员变量：只能访问静态变量
成员方法：只能访问静态成员方法
非静态方法：
成员变量：可以是静态的，也可以是非静态的
成员方法：可是是静态的成员方法，也可以是非静态的成员方法。
简单记：静态只能访问静态。
静态变量和成员变量的区别：
A:所属不同
静态变量属于类，所以也称为为类变量
成员变量属于对象，所以也称为实例变量(对象变量)
B:内存中位置不同
静态变量存储于方法区的静态区
成员变量存储于堆内存
C:内存出现时间不同
静态变量随着类的加载而加载，随着类的消失而消失
成员变量随着对象的创建而存在，随着对象的消失而消失
D:调用不同
静态变量可以通过类名调用，也可以通过对象调用
成员变量只能通过对象名调用
public static void main(String[] args) {
//Test t = new Test();
//t.print1();静态变量也叫类变量 成员变量也叫对象变量
Test.print2();
//method(); //method方法是静态的,直接能调用,是因为系统会默认加上类名.
Demo2Static.method();
}
public static void method() {
System.out.println();
}
}
class Test {
int num1 = 10;
static int num2 = 20;
/*public void print1() { //非静态的成员方法可以访问静态的成员
System.out.println(num1);
System.out.println(num2);
}*/
public static void print2() { //静态方法不能访问非静态的成员
//System.out.println(this.num1);
System.out.println(num2); //静态只能访问静态
}
Math类的随机数功能
/* A:Math类概述
* 类包含用于执行基本数学运算的方法
* B:Math类特点
* 由于Math类在java.lang包下，所以不需要导包。
* 没有构造方法，因为它的成员全部是静态的。
* C:获取随机数的方法
* public static double random():返回带正号的 double 值，该值大于等于 0.0 且小于 1.0。
* D:我要获取一个1-100之间的随机数，肿么办?
* int number = (int)(Math.random()*100)+1;*/
public static void main(String[] args) {
//需求：猜数字小游戏(数据在1-100之间)
for (int i = 0; i < 100; i++) {//遍历随机生成的100个数
int num = (int)(Math.random()*100)+1;//生成随机数
System.out.println(num);
}
1150
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
