/*面向过程*/
1.从Day1到Day4期间学习的都是面向过程，具体表现为一个类中包含一个主函数和多个其他函数。
2.强调的是功能行为，因为对象只有一个。
/*面向对象*/
面向对象是基于面向过程而言的，将功能封装进对象，强调了具备功能的对象。
/*成员变量和局部变量*/
成员变量：作用于整个类中，在堆内存中，有默认初始化值
局部变量：作用于一个函数中，存在于栈内存中，无默认初始化值
/*栈内存和堆内存*/
简单来说，栈就是一个很长的栈（数据结构中的栈，如果不理解可以当做是像线一样的一长串数据）。
里面存着各种逻辑，以及像整形，浮点型等数据，根据栈先进先出的原则，代码会一条条被执行，执行代码中包含着栈中可以存放的数据。
但数据量过大的时候，存入栈中会明显影响性能。所以，我们将大量的数据存入堆中，之后，栈中放堆的地址。//栈中通过堆内存的储存大量数据再通过地址来进行调用。
这样，在进行数据调用的时候，可以通过地址找到对应数据。//实际数据放入堆内存，而栈内存则只是调用地址
例子：
Person p=new Person("阿秋",20) //其中p(相当于地址)在栈内存当中，而类似于"阿秋",20等数据在推内存当中。
/*面向对象格式*/
class Q1
{
public static void main(String[] args)
{
Car c=new Car();
c.run();
//法二：
//Car.run();
Dog d=new Dog();
d.run();
}
}
class Car
{
static String name="兰博基尼";
static int price=10000000;
public static void run() //因为run()方法用static修饰，所以其打印语句用的变量也必须是静态。
{
System.out.println("阿秋的豪车是："+name+",价格是："+price+"$");
}
}
class Dog
{
String name="小黑";
void run() //没有用static修饰，所以变量也不用static静态。
{
System.out.println("名字是："+name);
}
}
/*面向对象特征一：封装*/
封装：隐藏对象的实际属性和实现方法，仅对外提供公共访问方式。
好处：1.将变化隔离
2.提高复用性
3.提高安全性
/*封装的标志性语法*/
set和get：一个是赋值一个是取值。
class Q1
{
public static void main(String[] args)
{
Person p=new Person();
p.setName("阿秋是天才");
System.out.println(p.getName());
}
}
class Person
{
private String name; //私有只在本类中有效
public void setName(String name) //赋值
{
this.name=name; //void修饰的是没有具体返回值类型的情况，除了打印语句之外还可以有赋值语句
}
public String getName()
{
return name; //取值
}
}
/*构造函数*/
构造函数的特点：
1.函数名和类名相同
2.不用定义返回值
3.不用写return语句
构造函数书写方式：
例如：Person(){} //函数名和类名相同
class Q1
{
public static void main(String[] args)
{
Person p=new Person();
new Person();
}
}
class Person
{
Person()
{
System.out.println("aaaa");
}
} //打印结果是aaaa和aaaa,原理对象只要已建立，不论是带名称的还是匿名的对象，就会调用其自带的构造函数
//每一个函数都自带一个空参的构造函数，打印结果为空
/*构造函数的重载*/
/*完成改名字的动作*/
class Person
{
private String name;
private int age;
{
System.out.println("中文"); //因为可能会出现所有构造函数都共有的一些代码，则发明出构造代码块解决这个问题
} //构造代码块优先于构造函数执行
Person()
{
System.out.println("A.name="+name+",age="+age);
}
Person(String name)
{
this.name=name;
System.out.println("B.name="+name+",age="+age);
}
Person(String name,int age)
{
this.name=name;
this.age=age;
System.out.println("C.name="+name+",age="+age);
}
public void setName(String name)
{
this.name=name;
}
public String getName()
{
return name;
}
}
class Q1
{
public static void main(String[] args)
{
new Person(); //打印结果是：A.name=null,age=0 ,String name的默认初始化值是null
new Person("阿秋"); //打印结果是：B.name=阿秋,age=0
Person p=new Person("阿秋",22); //打印结果是：C.name=阿秋，age=12
p.setName("邱锐刚");
System.out.println(p.getName());
} //构造函数建立对象不需要额外的Person p
}
/*this关键字*/
this：表面是用于区分同名对象的方法
1.它代表了本类对象
2.更细致的说是代表了所在函数所属对象的引用
/*定义个功能，可以比较2个人的年龄是否相同*/
class Person
{
int age; //在构造函数中的形参(局部变量)并不能代表全局变量，必须在类中定义全局的int age才能编译运行。
Person(int age)
{
this.age=age;
}
public boolean compare(Person p)
{
return this.age==p.age; //对于boolean类型用==符号
}
}
class Q1
{
public static void main(String[] args)
{
Person p1=new Person(22);
Person p2=new Person(23);
boolean b=p1.compare(p2); //b为boolean类型，用boolean进行修饰
System.out.println(b);
}
}
/*构造函数间this关键字的调用*/
/*构造代码块的应用*/
class Person
{
String name;
int age;
{
System.out.println("阿秋是天才"); //构造代码块
}
Person()
{
}
Person(String name)
{
this.name=name;
}
Person(String name,int age)
{
this(name); //1.在多个构造函数之前调用重复性很高的东西，用this(name)形式
this.age=age; //2.对于this语句只能定义在构造函数的第一行。
}
public void speak()
{
System.out.println("name是："+name+",年龄是："+age);
}
}
class Q1
{
public static void main(String[] args)
{
Person p1=new Person("阿秋",22);
Person p2=new Person("阿秋");
p1.speak();
p2.speak();
//打印结果为：
/*
阿秋是天才
阿秋是天才
name是：阿秋,年龄是：22
name是：阿秋,年龄是：0 //通过结果可以看出构造代码块是优先于对象执行的，无论是本类还是其他的
*/
}
}
|
|
收藏
淘帖
踩
