目录
1、面向过程和面向对象
面向过程
面向过程的程序设计思想（procedure -Oriented Programming)，简称POP
1、定义：
是一种具体步骤的操作，他是微观的。适合解决简单问题，先分析出解决问题的步 骤，然后一步一步的（用函数）去实现即可。c语言就是一个典型的面向过程的语言。结构简单，修改复杂。
（程序设计越来越复杂，单纯的面向过程就难以胜任设计程序的需求，现在大多数的语言都是面向对象，c++,C#,java,python....）
面向对象
面向对象的程序设计思想（ Object Oriented Programming），简称OOP
1、定义：
2、类和对象
1、什么是类？
类：具有相同特征（同一类）事物的抽象描述，是抽象的、概念上的定义。是一个模板。例如：人类，车类，学生类，是抽象的概念。
/*
发现类 某一类
访问权限修饰符（public / 无）
修饰符（final abstract）
class 修饰类
*/
//类的定义
public class 类名{
}注意：类是抽象概念，不能直接拿来使用， 要使用时，要创建类的实例，即对象。
类中有哪些结构？
成员变量：事物属性的描述(名词)
成员方法：事物的行为（可以做的事情 动词）
构造方法：初始化对象
代码块：一段没有名称的代码块
内部类： 即在类体中声明的类
1、成员变量
1、成员变量是定义在类中，方法体之外的变量。 2、成员变量可以使用Java语言中任何一种数据类型（包括基本类型和引用类型） 3、在定义成员变量时可以对其初始化，若不初始化，Java就使用默认值对其初始化 4、成员变量可以被类中方法，构造方法和特定类的语句块 访问 5、成员变量的作用范围为整个类体。
public class Car {
/*
成员变量(因为变量直接定义在类中，所以称为类的成员)
变量：事物属性的描述（名词）
*/
//成员变量的定义//未赋值
String name;//名字
float price;//价格
String color;//颜色
}2、成员方法
public class Car {
/*
成员方法
动词-->行为,功能
*/
public void run() {
System.out.println(name+"行驶");
}
public void stop() {
System.out.println(name+"停止");
}
public void showIn(){
System.out.println("名字："+name+" 价格 "+price+" 颜色 "+color);
}
}3、构造方法
1、作用：在构造方法中为创建对象的成员变量进行初始化赋值。
2、特点：
1、构造方法名与类名相同，且没有返回值，且不需要void修饰。
2、每个类都有构造方法，如果没有显式地为定义构造方法，Java将会为该类提供一个 默认无参 的构造方法。 但是只要在一个Java类中定义了一个有参构造的方法后，默认无参构造方法会失效。
3、一个类可以有多个构造方法。
public class Person {
String name;
int age;
String gender;
//无参构造方法
public Person() {
}
//有参构造方法
public Person(String n, int a, String g) {
name = n;
age = a;
gender = g;
}
//参数可任意
public Person(String n, String g, int a) {
name = n;
age = a;
gender = g;
}
}
4、代码块
1、定义：在类中声明的一个没有名字的代码块（方法体）。
2、代码块分类：
实例代码块：在每次创建一个新的对象时执行
静态代码块：（static）只要时在类被加载时，会自动执行，且只执行一次，与是否创建对象无关。
问题：类什么时候会被加载？
运行类中的main方法
访问类中的静态成员变量，静态成员方法，
创建类的对象，，
1、静态代码块的使用
public class daiMaKuai {
static int a=20;//静态成员变量
int b=30;//非静态成员变量
//实例代码块
{
System.out.println("实例代码块，在创建对象时，不需要显示的调用，会自动执行1");
}
{
System.out.println("实例代码块，在创建对象时，不需要显示的调用，会自动执行2");
}
//静态代码块
static{
System.out.println("静态代码块，在类被加载时，自动执行1");
}
static{
System.out.println("静态代码块，在类被加载时，自动执行2");
}
public static void main(String[] args) {
//类被加载，静态代码块执行
}
}
2、实例代码块的应用
public class TestDaiMaK {
public static void main(String[] args) {
daiMaKuai d1 = new daiMaKuai();
new daiMaKuai();
System.out.println(daiMaKuai.a);
System.out.println(d1.b);
}
5、内部类（后期会涉及）
2、什么是对象？
对象：是类的具体，是实际存在的，可以使用的。是类的一个实例。
是以类为模板在内存中创建的实际存在的实例。必然具备该类事物的属性和行为（即方法）。
1、对象的创建和使用
创建类的实例，即对象时，使用new关键字。
对象是类的一个实例，必然具备该类事物的属性和行为（即方法）。 使用对象名.属性或对象名.方法的方式访问对象成员（包括属性和方法）
对象的创建和使用：
Car bm = new Car();
public class TestCar {
public static void main(String[] args) {
Car成员变量方法 bm = new Car成员变量方法();//Car bm:使用Car类作为类型声明一个变量 Car类型的变量bm.
//new Car():使用new关键字创建一个具体的对象，对象存在内存中，然后调用Car类的构造方法初始化对象。
//同一类的每个对象有不同存储空间。
//= 把右边创建的对象（的地址）赋值给左边的变量。左边的变量就可以表示内存中的对象。
bm.color = "red";
bm.name = "宝马";
bm.price = 350000;
bm.run();
bm.stop();
bm.showIn();
Car成员变量方法 bc = new Car成员变量方法();
bc.name = "奔驰";
bc.color = "blue";
bc.price = 100000;
bc.run();
bc.stop();
bm.showIn();
}
}4、方法的重载
1、定义：在一个类中，有多个名称相同的，但参数不同的方法。
那如何在调用时区分同名的方法?
通过方法的参数的
1、个数
2、类型
3、顺序来区分方法
注意：构造方法和成员方法都可以实现方法的重载， 方法的重载与返回值没有关系。
public class Person {
String name;
int age;
String gender;
public Person() {
}
public Person(String n, int a, String g) {
name = n;
age = a;
gender = g;
}
public Person(String n, String g, int a) {
name = n;
age = a;
gender = g;
}
public void eat() {
System.out.println(name + "吃饭");
}
public void eat(String food) {
System.out.println("吃了" + food);
}
}
5、对象与引用
- java 语言中除基本类型之外的变量类型都称之为引用类型。
- Java中的对象是通过引用对其操作的。
对Car bm = new Car()分析：
Car bm:使用Car类作为类型声明一个引用类变量 。即声明一个Car类型的变量bm。所谓Car 类的引用，就是以后可以用来指向Car对象的对象引用。
new Car():使用new关键字，以car类为模板，创建了一个具体的Car类对象，对象存在内存 中，然后调用Car类的构造方法初始化对象。有两个实体： Car bm是对象引用变量，new Car()是对象本身。
= 把右边创建的对象（的地址）赋值给左边的变量。左边的变量就可以表示内存中的对象。
同一类的每个对象有不同存储空间。
6、值传递
1、值传递
（形参数类型是基本数据类型)
方法调用时，实际参数把它的值传递给对应的形式参数，形式参数只是用实际参数的值初始化自己的存储单元内容，是两个不同的存储单元，所以方法执行中形式参数值的改变不影响实际参数的值。
2、引用传递
(形参数类型是引用数据类型参数)
也称为传地址。方法调用时，实际参数是对象，这时实际参数与形式参数指向同一个地址，在方法执行中，对形式参数的操作实际上就是对实际参数的操作，这个结果在方法结束后被保留了下来，所以方法执行中形式参数的改变将会影响实际参数。
基本类型传递的是该数据值本身。引用类型传递的是对对象的引用，而不是对象本身 。
但是无论是值传递还是引用传递,其本质都是传值,所以也都统称值传递。
public class dataBase {
//基本数据类型
public void base(int b){
b=20;
System.out.println("b="+b);//20
}
public static void main(String[] args) {
int a=10;
dataBase t=new dataBase();
t.base(a);
System.out.println("a="+a);//10
}
}
public class dataUse {
/*
引用类型传递-----引用数据类型作为参数传递，传递的只是对象的地址，实参和形参指的是同一个对象
任何一方改变对象的值，另一方也会改变。
*/
public void use(Use b){
b.name="基本类型";
System.out.println("b="+b.name);//基本类型
}
public static void main(String[] args) {
//先创建一个类Use，然后创建Use的对象
Use u=new Use();
//使用成员变量
u.name="引用类型";
//创建对象
dataUse a=new dataUse();
//使用另一个成员变量
a.use(u);
System.out.println("u="+u.name);//基本类型
}
}
7、包
1、简介：
在编写 Java 程序时，随着程序架构越来越大，类的个数也越来越多，这时就会发现管理程序中维护类名称也是一件很麻烦的事，尤其是一些同名问题的发生。有时，开发人员还可能需要将处理同一方面的问题的类放在同一个目录下，以便于管理。
- 为了解决上述问题，Java 引入了包（package）机制，提供了类的多层命名空间，用于解决类的命名冲突、类管理等问题。
- 使用package关键字修饰包
- 每个类属于一个特定的包,所以java中一个类的完整名称等于包名+类名。
2、包的作用
- 按照不同的功能管理类。
- 避免类重名
- 控制访问权限，在不同的包中，对不同权限的成员进行访问限制。
3、包的命名规范
在包名中，可以使用”."来区分包的级别；包名一般情况下是小写
包目前至少三级
第1级：用于指项目类型。 如：com org gov edu
第2级：用于指公司名字。 如：baidu sun huawei
第3级：用于指项目名字。 如：oa cms erp
第4级：用于指功能模块名称。 如：wed service dao config
注：
当在一个类中使用其他包中的类时,需要先使用import关键字导入进来. 只有java.lang包中的类比较特殊,使用时不需要导入。
8、访问权限修饰符
Java语言有四个权限访问修饰符，权限从大到小依次为：
1）public ：公共权限。------->修饰类、属性、方法。可以在任意类中访问。
2）protected：受保护的权限。------>修饰属性、方法。可以在同包类访问，如果不是同包类，必须是该类的子类才可以访问。
3）default：同包权限。----->修饰类、属性、方法。只能在同包的类访问。
4）private：私有权限。------->修饰属性、方法。 只能在本类中访问。
5) 什么都不写：默认权限。----->修饰类，成员变量，成员方法，内部类。 在本类中，同包的其它类中可以访问到。
public class Animal {
public String pubname;//公共权限修饰的成员，在任何地方都可以访问到。
protected String proname;//受保护权限 在本类中，同包的其他类可以访问到，还可以在其他包中的子类访问
String name;//默认权限 在本类中，同包的其他类可以访问
private String priname;//私有权限 在本类中访问
public static void main(String[] args) {
Animal animal = new Animal();
animal.proname = "zhshbf";
animal.pubname = "sjinrie";
animal.name = "sjnkie";
animal.priname = "45578";//在本类中可以访问到
}
}
542
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
