面向过程和面向对象的设计思想
面向过程(procedure oriented programming)缩写POP
面向过程就是分析得出要进行的每一个步骤一步一步的执行。
面向对象(objectoriented programming ) 缩写OOP
面向对象就是以分类的方式将问题分开处理,的以更加明确的处理问题,这是更倾向于人类思考问题的方式。
面向过程适合于处理简单的问题,直接关注流程,简单有效。
面向对象适合于处理复杂的问题,先使用面向对象的方式对整体关系作出分类,然后,根据不同的类深入细节的处理。
面向对象无法取代面向过程,他们是相辅相成的。面向对象关注于从宏观上把握事物之间的关系,在具体到如何实现某个细节时,仍然采用面向过程的思维方式。面向对象如果离开了面向过程,就无法实现真正的落地,成为无源之水。
java类
类就像是一个模板,描述某一类对象的属性和方法。
类是描述某一类客观存在的群体的基本特征的抽象。
类的结构
成员变量:对象的基本属性的描述。
方法:对象的行为。(对象可以做的事情)
构造方法:用于创建一个或多个对象的方法。
内部块:在类的内部声明的类。
块:代码块。
类的定义
package object_Day1;
/**
* 类的声明格式为:
* [访问权限修饰符] [修饰符] class 类名{ }
* 访问权限修饰符:public default
* 修饰符:final abstract
* class用来定义一个类
* 类名首字母大写 见名知意 驼峰命名法
*/
public class Car {
// 成员变量: [访问权限修饰符] [修饰符] 数据类型 变量名称 [=值]
String name; //名称
String color; // 颜色
float price; //价格
/*
方法的声明格式为:
[访问权限修饰符] [修饰符]/void 方法名(){
代码块;
[return 返回值;]
}
}
*/
public void start(String a){
this.name = a;
System.out.println(a+"汽车启动");
}
public int add(int a, int b){
int he = a + b;// he 局部变量
return he;
}
}
java对象
/*
创建汽车对象:
以Car类为模板,
Car baoma = new + Car(); new 关键字+默认构造方法();
在内存空间创建一个对象 实际存在的 实例化对象
Car baoma 以Car类作为类型 声明一个变量 指向内存空间中的具体的对象
使用baoma变量访问对象中属性,方法
通过类可以创建无数个对象
*/
Car baoma = new Car();
baoma.name = "x5";
baoma.price = 600000;
baoma.color = "红色";
Car benchi = new Car();
benchi.name = "GTR";
benchi.price = 700000;
benchi.color = "黑色";
System.out.println(baoma.name);
System.out.println(baoma.price);
System.out.println(baoma.color);
baoma.start();
baoma.run();
baoma.stop();
System.out.println(benchi.name);
System.out.println(benchi.price);
System.out.println(benchi.color);
benchi.start();
benchi.run();
benchi.stop();
类中变量
成员变量
成员变量是定义在类中,方法体之外的变量。
成员变量可以使用Java语言中任何一种数据类型(包括基本类型和引用类型)。
在定义成员变量时可以对其初始化,如果不对其初始化,Java使用默认的值对其初始化。
成员变量在创建对象的时候会从类中复制一份到对象中。
成员变量可以被类中方法、构造方法和特定类的语句块访问。
成员变量的作用范围为整个类体。
局部变量
在方法、构造方法或者语句块中定义的变量被称为局部变量。
局部变量可以使用Java语言中任何一种数据类型(包括基本类型和引用类型)。
局部变量在使用前必须初始化赋值。
变量声明和初始化都是在方法中,方法结束后,变量就会自动销毁。
类变量
类变量:(也叫静态变量)类变量也声明在类中,方法体之外,但必须声明为static类型。
类中的方法
成员方法:成员方法是定义在类中。这种方法在创建对象的时候创建。
语法格式:
修饰符 返回值类型/void 方法名 ( 参数列表) {
方法体语句;
[return 返回值]
}
构造方法:用来创建对象的方法
package object_Day1;
/*
构造方法是定义在类中用来创建对象的方法
*/
public class Structural {
String name;
int age;
//构造方法
public Structural(){
System.out.println("无参的构造方法");
}
//构造方法对对象的成员变量初始化
public Structural(String n){
this.name = n;
System.out.println(name+"的构造方法");
}
// 方法的重载
public Structural(String n,int a){
//数量不同
}
public Structural(int a,String n){
//顺序不同
}
public Structural(int n,int a){
//数据类型不同
}
//成员方法
public void run(String x){
System.out.println("name="+x);
}
//成员方法的重载
public void run(String x,int a){//数量不同
System.out.print("name="+x+" ");
System.out.println("age="+a);
}
public void run(int a,String x){//顺序不同
System.out.print("name="+x+" ");
System.out.println("age="+a);
}
public void run(int x,int a){//数据类型不同
System.out.print("name="+x+" ");
System.out.println("age="+a);
}
}
类方法:(也叫静态方法)类方法也声明在类中,但必须声明为static类型
方法重载
方法的重载是指一个类中可以定义有相同的名字,但参数不同的多个方法。
调用时,会根据不同的参数表选择对应的方法。
方法重载
同一个类中
方法名相同
参数不同(可以有三方面的不同)
数量不同
类型不同
顺序不同
注意:方法重载跟方法的返回值类型,访问权限没有任何关系
对象与引用
Java 语言中除基本类型之外的变量类型都称之为引用类型。
Java中的对象是通过引用对其操作的.
例如: 我们有一个自定义类为Car(汽车类)
class Car{
String color;
String name;
String model;
}
Car car= new Car();
通常把这条语句的动作称之为创建一个对象,其实,它包含了三个动作。
1)右边的“new Car()”,是以Car类为模板,调用Car类的构造函数,在堆空间里创建一个Car类对象。
2)左边的“Car car”创建了一个Car类引用变量。所谓Car类的引用,就是以后可以用来指向Car对象的对象引用。
3)”=”操作符使对象引用指向刚创建的那个Car对象。
我们可以把这条语句拆成两部分:
Car car;
car= new Car();
这样写,就比较清楚了,有两个实体:一是对象引用变量,一是对象本身。
基本类型和引用类型的区别
值传递与引用传递
Java中进行方法调用中传递参数时,参数传递有两种:
值传递:(形式参数类型是基本数据类型):方法调用时,实际参数把它的值传递给对应的形式参数,形式参数只是用实际参数的值初始化自己的存储单元内容,是两个不同的存储单元,所以方法执行中形式参数值的改变不影响实际参数的值。
引用传递:(形式参数类型是引用数据类型参数):也称为传地址。方法调用时,实际参数是对象,这时实际参数与形式参数指向同一个地址,在方法执行中,对形式参数的操作实际上就是对实际参数的操作,这个结果在方法结束后被保留了下来,所以方法执行中形式参数的改变将会影响实际参数。
基本类型传递的是该数据值本身。引用类型传递的是对对象的引用,而不是对象本身 。
static关键字
static被称为静态,可以用来修饰类的属性,方法,代码块,内部类。
随着类的加载而加载
优先于对象存在
修饰的成员,被所有对象所共享
可不创建对象,直接被类调用
static方法可以使用对象调用,也可以直接用类名调用,建议用类名直接调用
在static方法内部只能访问类的static属性,不能访问类的非static属性。
package object_Day2;
public class Ticket {
static int yu_piao = 10;
public static void mai(){
yu_piao--;
System.out.println("剩余票量"+yu_piao);
}
public static void main(String[] args) {
Ticket.mai();
Ticket.mai();
Ticket.mai();
Ticket.mai();//没有创建对象也可以访问静态方法
}
}
静态变量和非静态变量的区别?
1.内存分配
静态变量在类程序初始化时,就存在于内存当中,直到它所在的类的程序运行结束时才结束;
非静态变量需要被实例化后才会分配内存。
2.生存周期
静态变量生存周期为程序的存在周期;
非静态变量的存在周期取决于实例化的类的存在周期。
3.调用方式
静态变量只能通过“类.静态变量名”调用,类的实例不能调用;
非静态变量当该变量所在的类被实例化后,可通过实例化的类名直接访问。
4.共享方式
静态变量是全局变量,被所有类的实例对象共享,即一个实例的改变了静态变量的值,其他同类的实例读到的就是变化后的值;
非静态变量是局部变量,不共享,即一个类的不同实例访问的非静态变量可以是不同的值。
5.访问方式
静态成员不能访问非静态成员;
非静态成员可以访问静态成员。
代码块
代码块在类中声明,类似一个没有名称的方法体(代码块),代码分实例块和静态块
实例块:每次创建对象时自动调用
{
//任何符合语法的Java代码
}
静态块:类加载时自动调用,仅一次,与是否创建对象无关。
static {
//任何符合语法的Java代码
}
package object_Day2;
public class Demo {
static int a = 10;
{
System.out.println("成员方法");
}
static {
System.out.println("静态方法");
}
public static void main(String[] args) {
new Demo();
new Demo();
new Demo();
new Demo();
}
}
包
物理上是文件夹
是用来管理类的
作用
避免类重名
按照不同功能管理类
控制访问权限
package object_Day3;
//import java.util.Date;
//import java.sql.Date;
/**
* 包就是文件夹
* 作用是为了管理类 避免类名的重复 可以让一个类名应用多次
*
* 全类名 = 包名(类的地址) + 类名
* 全类名是当一个程序导入多个重名类是用来区分类的
* 当用全类名的时候便可以不用使用import导入包
*/
public class Demo {
java.util.Date date = new java.util.Date();
java.sql.Date dat = new java.sql.Date(1000);
}
包(package)的命名规范:
在包名中,可以使用.号来区分包的级别;包名一般情况下是小写
第一级 指该项目的类型,如com,org,gov等,
第二级 指项目所开发或者运行的公司名称,如:oracle,sun,huawei等
第三级 指项目的名称,如:bcms,oa,erp,cms等
第四级 指项目模块的名称,如:bean,action,exception等
访问权限修饰符
•Java语言有四个权限访问修饰符,权限从大到小依次为:
1)public :公共权限 修饰类、属性、方法。(可以被任意类访问)
2)protected:受保护的权限 修饰属性、方法。(可以被同包类访问,如果不是同包类,必须是该类的子类才可以访问。)
3)default:同包权限 修饰类、属性、方法。(只能被同包的类访问)
4)private:私有权限 修饰属性、方法。 (只能在本类中访问)
package object_Day3;
/**
* public 公共的 修饰类 属性 方法
* protected 受保护的 修饰属性 方法
*/
public class Demo1 {
public int a;
protected int b = 10;
int c = 10;
private int d = 10;
public void add(){
System.out.println(a);
System.out.println(b);
System.out.println(c);
System.out.println(d);
}
public static void main(String[] args) {
Demo1 a = new Demo1();
a.add();
}
}