前言：记得大一的第一个学期，学的第一门编程语言是C语言，它是基于面向过程的，不管遇到什么都会先考虑它能实现什么功能；比如说，我们要用程序来描述一个人，如果是以往的结构化编程，我们可能会这样;例如用C语言的话，可能会建立一个结构体:struct Person{ 姓名; 年龄; 等等;...}然后用定义的一些函数来描述他的行为。比如void walk(struct p); void eat(struct p);等等。然后使用 walk(p) 来描述行走，使用eat(p)来描述吃饭等。这样不利于程序结构的维护。开发效率也不高。但是用java面向对象方式，这一切就显得自然了。我们建立一个类，表示人:class Person{ 姓名 性别 体重 身高等..(人类都有的属性) 吃饭 睡觉 等行为(也就是人类都有的行为)}然后将类产生一个实例，就产生了一个'人'的对象。Person xiaobai = new Person("小白",身高，体重...等参数);如果要描述祖先后代的关系，很简单。只要让人类继承自Animal即可。class Animal{ ......}class Person extends Animal{ .......}这样动物有的属性和行为
面向对象不是java特有的，只是一种思想，如果你愿意，用结构化语言C语言也可以写出面向对象的代码。
一、面向对象
（1） 理解：面向对象是相对于面向过程而言的，其实它们都是一种思想；
面向过程 强调的是功能行为。
面向对象 将功能封装进对象，强调具备了功能的对象。它是基于面向过程得的。
（2）特点：
a：是一种符合人们思考习惯的思想
b：可以将复杂的事物简单化
c：将程序员从执行者转换成了指挥者
完成需求时：
先要求去找具有所需的功能的对象来用，如果该对象不存在，那么创建一个具有所需功能的对象，这样简化开发并提高复用。
（3）类与对象的关系：
把事物转换成类：
A：成员变量 定义在类中，方法外。
B：成员方法 和以前的区别是去掉static。
类：是相关的属性和行为的集合，是一个抽象的概念。
对象：是某种事物的具体存在，具体的表现形式。
举例： 类：人
对象：张三，李四，王五。。。
案例：学生类
生活中描述事物无非就是描述事物的属性和行为。如：人有身高，体重等属性，有说话，打球等行为。
Java中用类class来描述事物也是如此
属性：对应类中的成员变量。
行为：对应类中的成员函数。
定义类其实是在定义类中的成员(成员变量和成员函数)。
下面来写一个例子帮助理解：
//学生类
class Student
{
//姓名
String name;
//年龄
int age;
//性别
char sex;
//学习的方法
public void study()
{
System.out.println("学生爱学习");
}
//吃饭的方法
public void eat()
{
System.out.println("学生吃饭");
}
//睡觉的方法
public void sleep()
{
System.out.println("学习睡觉");
}
}
//学生测试类
class StudentTest
{
public static void main(String[] args)
{
//你要想使用学生的内容，就首先必须明确你用哪个学生使用的。
//如何明确一个类的具体对象呢?通过new造出来。
//格式：类名 变量名 = new 类名(); 这就表示创建了一个数据类型为类名的变量。
//这个变量其实是一个对象。
//我要创建一个学生
Student s = new Student();
//System.out.println(s); //Student@1175422
//那么,如何使用这个类中的成员变量和方法呢?
//必须通过对象调用。
//格式：
//成员变量：对象名.成员变量
//成员方法：对象名.成员方法
//获取成员变量的值
System.out.println(s.name+"***"+s.age+"***"+s.sex);//null,0,
//给成员变量赋值
s.name = "林青霞";
s.age = 26;
s.sex = '女';
//再次使用
System.out.println(s.name+"***"+s.age+"***"+s.sex);
//使用成员方法
s.study();
s.eat();
s.sleep();
}
}A：创建对象
格式：类名 对象名=new 类名（）；
B：使用成员变量和成员方法
对象名.成员变量
对象名.成员方法
（5）面向对象开发，设计，特征
开发的过程：其实就是不断的创建对象，使用对象，指挥对象做事情。
设计的过程：其实就是在管理和维护对象之间的关系。
面向对象的特征：
封装(encapsulation)
继承(inheritance)
多态(polymorphism)
（6）成员变量和局部变量的区别：
1、定义位置区别：
成员变量：定义在类中，方法外。
局部变量：定义在方法中，或者方法声明上。
2、初始化值的区别：
成员变量：都有默认初始化值。
局部变量：没有默认初始化值，想要使用，必须先赋值。
3、存储位置区别：
成员变量：存储在堆中； 局部变量：存储在栈中。
4、生命周期区别：
成员变量：随着对象的创建而存在，随着对象的消失而消失。
局部变量：随着方法的调用而存在，随着方法调用完毕而消失。
（7）匿名对象
1、 理解：就是没有名字的对象，即对象的简化形式。
2、匿名对象两种使用情况：
a：当对对象方法仅进行一次调用时
b：匿名对象可以作为实际参数进行传递
举一个例子理解一下：
class Student
{
public void show()
{
System.out.println("student -- show");
}
}
class Test
{
//引用类型作为形式参数
public void print(Student s)
{
s.show();
}
public void print(int a)
{
System.out.println(a);
}
}
class NiMingTest
{
public static void main(String[] args)
{
//如何使用show()方法呢?
Student s = new Student();
s.show();
s.show();
s.show();
//匿名对象的使用
new Student().show();
new Student().show();
new Student().show();
Test t = new Test();
//Student s2 = new Student();
//t.print(s2);
t.print(new Student());
}
}
（8）面向对象的特征之一-------封装
a：封装：是指隐藏对象的属性和实现细节，对外提供公共访问方式。
类、方法等其实都是封装的具体体现。
b：好处：
1、将变化隔离
2、便于使用
3、提高重用性
4、提高安全性
c：封装的原则：
将不需要对外提供的内容都隐藏起来。 把属性都隐藏，提供公共方法对其访问。
d：如果我们不想让外界直接通过对象名.成员变量 访问数据。该怎么解决呢? java就给你提供了一个修饰符 private。
private关键字：
是一个访问权限修饰符，用于修饰成员变量和成员方法。 注意：被私有化的成员只在本类中有效。
常见应用：类中的所有成员变量私有，给出对应的get/set方法对其进行访问，提高对数据访问的安全性。
附一个例子帮助理解：
class Student
{
String name;
private int age;
public void setAge(int a) //设置年龄的方法，同时判断设置的年龄是否正确
{
if(a<0 || a>150)
{
System.out.println("年龄有问题");
}
else
{
age = a;
}
}
public int getAge()
{
return age;
}
public void show() //显示名字和年龄的方法
{
System.out.println(name+"***"+age);
}
}
class PrivateTest
{
public static void main(String[] args)
{
//创建对象
Student s = new Student();
s.show();//null***0
//给成员变量赋值
s.name = "张三";
//s.age = 26;
//s.age = -26;
s.setAge(26);
s.show();
//我现在要想直接获取age的值怎么办?
//System.out.println(s.age);
System.out.println(s.getAge());
}
}
a：格式及特点
格式：
访问权限修饰符类名(参数...){}
访问权限修饰符: public ，private
特点：
A:方法名和类名相同
B:没有返回值类型
C:没有具体的返回值
b：作用：给对象进行初始化。
注意事项：
1、如果你不给构造方法，jvm会自动给你一个无参构造方法。
2、如果你给出了构造方法，那么，jvm将不再提供无参构造方法，这个时候你如果要使用无参构造方法：只能自己提供。
推荐：永远手动给出无参构造方法。
c：构造方法重载 其实就是构造方法接收不同的参数。
d：给成员变量赋值： A：通过set方法，推荐使用。
B：通过构造方法。
附一个例子帮助理解：
class Person
{
private String name; //定义两个成员变量 姓名
private int age; //年龄
//无参构造方法
public Person()
{
//System.out.println("无参构造方法");
}
//带参构造
public Person(String n)
{
name = n;
}
/*
这不是构造方法
public void Person()
{
System.out.println("haha");
}
*/
public void setName(String n)
{
name = n;
}
public String getName()
{
return name;
}
public void setAge(int a)
{
age = a;
}
public int getAge()
{
return age;
}
}
class PersonTest
{
public static void main(String[] args)
{
//创建对象
Person p = new Person();
p.setName("hello"); //给名字赋值
System.out.println(p.getName());
System.out.println("-------------");
Person p2 = new Person("张三"); //创建第二个对象
System.out.println(p2.getName());
}
}
（10）代码块
1、 理解：就是由{ }括起来的代码。
2、分类：定义在方法中的代码块，叫局部代码块。
作用是：让变量尽可能早的从内存中消失，提高效率。
定义在方法外的代码块，叫构造代码块。
作用是：把所有构造方法中的共同的内容定义在构造代码块中。
3、执行顺序：静态代码块--->构造代码块--->构造方法
4、注意事项：静态代码块只执行一次
对象初始化过程：
注：这个过程是视频里面老师分析的，我觉得特别好，就拿过来，帮助理解，以后还可以看看。
（11）this 关键字
A：特点：this代表其所在函数所属对象的引用。换言之：this代表当前类的引用。
简单记：在方法中，哪个对象调用方法，this就代表谁。
B：应用场景：解决局部变量隐藏成员变量问题。
（12）static（静态）关键字
A：是一个关键字，可以修饰成员变量和成员方法。
B：静态的特点：
1、随着累的加载而加载
2、优先于对象存在
3、被类的所有对象存在
4、可以通过类名调用
C：静态的注意事项：
1、在静态方法中是没有this关键字的，因为静态是随着类的加载而加载，而this是对象创建才存在的。
2、静态方法只能访问静态成员变量和静态成员方法。
3、静态的内容可以通过对象调用，也可以通过类名调用。 但是一般推荐使用类名调用。
附一个代码帮助理解：
class Demo
{
int num = 10;
static int num2 = 20;
//非静态方法
public void show()
{
System.out.println(num);
System.out.println(num2);
}
public void method()
{
System.out.println("method");
show();
function();
}
//静态方法
public static void function()
{
//System.out.println(this.num);
System.out.println(num2);
}
public static void test()
{
System.out.println("test");
//show();
function();
}
}
class StaticDemo3
{
public static void main(String[] args)
{ //创建对象
Demo d = new Demo();
d.show(); //d调用show方法
d.function(); //通过对象d调用function方法
d.method(); //d调用method方法
//通过类名访问
Demo.function();
}
}
一直学的是C语言，一时的接受面向对象还有点转不过来，以后要多加练习！ 早点找到适合自己理解的方法~~
877
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
