1.（了解） 面向对象 vs 面向过程 例子：人开门；把大象装冰箱
2.面向对象的编程关注于类的设计！
1）一个项目或工程，不管多庞大，一定是有一个一个类构成的。
2）类是抽象的，好比是制造汽车的图纸。
而具体的一辆一辆的车，是根据图纸制造的，实际上就是类的实例化
3.完成一个项目（或功能）的思路
1）所要完成的功能对应的类的对象是否存在。
2）若存在，则通过对象直接调用对应的类中的属性或方法即可 。 例如 Scanner。
3）若不存在，需要创建类的对象。甚至说，类都不存在，就需要设计类。
4.面向对象编程的三条主线：
1）类及类的构成成分：属性 方法 构造器 代码块 内部类
2）面向对象编程的特征：封装性 继承性 多态性 （抽象性）
3）其它的关键字：this super package import static final abstract interface ...
1.关于于类的设计
2.类的组成成分：
1） 属性（成员变量，Field）
2）方法（成员方法，函数，Method）
2.1属性：
* 成员变量 vs 局部变量
* 相同点：1.遵循变量声明的格式： 数据类型 变量名 = 初始化值
* 2.都有作用域
* 不同点：1.声明的位置的不同 ：成员变量：声明在类里，方法外
* 局部变量：声明在方法内，方法的形参部分，代码块内(main方法也是方法，所以main方法里边的变量也是存放在栈空间)
* 2.成员变量的修饰符有四个：public private protected 缺省
* 局部变量没有修饰符，与所在的方法修饰符相同。
* 3.初始化值：一定会有初始化值。
* 成员变量：如果在声明的时候，不显式的赋值，那么不同数据类型会有不同的默认初始化值。
* byte short int long ==>0
* float double ==>0.0
* char ==>空格
* boolean ==>false
* 引用类型变量==>null
* 局部变量：一定要显式的赋值。（局部变量没有默认初始化值）
* 4.二者在内存中存放的位置不同:成员变量存在于堆空间中；局部变量：栈空间中
*
* 总结：关于变量的分类：1）按照数据类型的不同：基本数据类型（8种） & 引用数据类型
* 2）按照声明的位置的不同：成员变量 & 局部变量
2.2 方法：提供某种功能的实现 main方法也是方法，main方法里边的属性也必须要赋值。
* 1）实例：public void eat(){//方法体}
* public String getName(){}
* public void setName(String n){}
* 格式：权限修饰符 返回值类型（void:无返回值/具体的返回值） 方法名(形参){}
*
* 2)关于返回值类型：void：表明此方法不需要返回值
* 有返回值的方法：在方法的最后一定有return + 返回值类型对应的变量
* 记忆：void 与return不可以同时出现一个方法内。像一对“冤家”。
*
* 3)方法内可以调用本类的其他方法或属性，但是不能在方法内再定义方法！
public class Zoo {
public static void main(String[] args) {
//基本数据类型的声明：数据类型 变量名 = 初始化值
int i = 10;
//类的实例化:如下的a1就是一个实实在在的对象
Animal a1 = new Animal();
//int[] arr = new int[10];
System.out.println("name:" + a1.name + " age:" + a1.age);
//通过对象调用属性
a1.name = "花花";
a1.age = 3;
System.out.println("name:" + a1.name + " age:" + a1.age);
//通过对象调用方法
a1.eat();
a1.sleep();
//再创建一个类的对象
Animal a2 = new Animal();
System.out.println("name:" + a2.name + " age:" + a2.age);//null 0
a2.name = "小花";
System.out.println("name:" + a1.name + " age:" + a1.age);
System.out.println("name:" + a2.name + " age:" + a2.age);
//a3不意味着相较于a1重新创建的一个对象，而是a1与a3共用一个对象实体
Animal a3 = a1;
System.out.println("name:" + a3.name + " age:" + a3.age);//与a1一样
a3.name = "维尼熊";
System.out.println("a1：name:" + a1.name + " age:" + a1.age);
System.out.println(a2.getName());//a2.name;
System.out.println(a2.desc());
}
}
class Animal{
//1.属性
String name;
int age;
//2.方法
public void eat(){
System.out.println("动物进食");
}
public void sleep(){
System.out.println("动物休眠");
//return;
}
public String getName(){
return name;
}
public int getAge(){
System.out.println("hello");
return age;
//其后不可以声明语句
//System.out.println("hello");
}
//当通过对象调用此方法时，会将方法的方法的返回值提供给方法的调用者，也就是当前的对象。
public String desc(){
if(age > 2){
return "恰同学少年";
}else{
return "还是看动画片的年龄";
}
}
public void setName(String n){//n:局部变量
name = n;
}
public void addAge(){
int i = 0;//局部变量
age += i;
}
public void info(){
// 可以在方法内调用本类的其他方法，但是不可以在方法内定义新的方法
eat();
sleep();
// public void breath(){
// System.out.println("呼吸");
// }
}
// System.out.println("hello!");
3.面向对象编程的思想的落地法则一：
1）设计并创建类及类的成分
2）实例化类的对象
3）通过“对象.属性”或"对象.方法"的形式完成某项功能
4.类的初始化的内存解析
4.1 内存划分的结构：
栈(stack):局部变量 、对象的引用名、数组的引用名
堆(heap):new 出来的“东西”（如：对象的实体，数组的实体），含成员变量
方法区:含字符串常量
静态域：声明为static的变量
4.2 理解的基础上，学会基本的创建的类的对象在内存中的运行。
* 方法的重载（overload）
* 要求：1.同一个类中 2.方法名必须相同 3.方法的参数列表不同（①参数的个数不同②参数类型不同）
* 补充：方法的重载与方法的返回值类型没有关系！
//如下的四个方法构成重载
//定义两个int型变量的和
public int getSum(int i,int j){
return i + j;
}
//定义三个int型变量的和
public int getSum(int i,int j,int k){
return i + j + k;
}
//定义两个double型数据的和
public double getSum(double d1,double d2){
return d1 + d2;
}
//定义三个double型数组的和
public void getSum(double d1,double d2,double d3){
System.out.println(d1 + d2 + d3);
}
//不能与如上的几个方法构成重载
// public int getSum1(int i,int j,int k){
// return i + j + k;
// }
// public void getSum(int i,int j,int k){
// System.out.println(i + j + k);
// }
//以下的两个方法构成重载。
public void method1(int i,String str){
}
public void method1(String str1,int j){
}
* 可变个数的形参的方法：
* 1.格式：对于方法的形参： 数据类型 ... 形参名
* 2.可变个数的形参的方法与同名的方法之间构成重载
* 3.可变个数的形参在调用时，个数从0开始，到无穷多个都可以。
* 4.使用可变多个形参的方法与方法的形参使用数组是一致的。
* 5.若方法中存在可变个数的形参，那么一定要声明在方法形参的最后。
* 6.在一个方法中，最多声明一个可变个数的形参。
//如下四个方法构成重载
//在类中一旦定义了重载的可变个数的形参的方法以后，如下的两个方法可以省略
// public void sayHello(){
// System.out.println("hello world!");
// }
// public void sayHello(String str1){
// System.out.println("hello " + str1);
// }
//可变个数的形参的方法
public void sayHello(String ... args){
for(int i = 0;i < args.length;i++){
System.out.println(args[i] + "$");
}
//System.out.println("=====");
}
public void sayHello(int i,String ... args){
//public void sayHello(String ... args,int i){
System.out.println(i);
for(int j = 0;j < args.length;j++){
System.out.println(args[j] + "$");
}
}
public void sayHello1(String[] args){
for(int i = 0;i < args.length;i++){
System.out.println(args[i]);
}
}
* 一、类的第三个成员：构造器(constructor 构造方法)
* constructor:建造者
* 构造器的作用：①创建对象 ②给创建的对象的属性赋值
*
* 1.设计类时，若不显式声明类的构造器的话，程序会默认提供一个空参的构造器.
* 2.一旦显式的定义类的构造器，那么默认的构造器就不再提供。
* 3.如何声明类的构造器。格式：权限修饰符 类名(形参){ }
* 4.类的多个构造器之间构成重载
package text;
import java.util.Scanner;
public class Circle {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
double g=sc.nextInt();
TestCircle tc=new TestCircle();
tc.setRadius(g);
double m=tc.mianji();
System.out.println(m);
}
}
class TestCircle{
private double radius;
public double getRadius(){
return radius;
}
public void setRadius(double r){
this.radius=r;
}
public double mianji(){
return 3.14*radius*radius;
}
}
* 二、类对象的属性赋值的先后顺序：①属性的默认初始化 ②属性的显式初始化③通过构造器给属性初始化
* ④通过"对象.方法"的方式给属性赋值
public class lianxixixi{
String pinpai;
String jixing;
double price;
double yh;//油耗
double lc;//里程
double yxrj;//油箱容积
double syyl;//剩余油量
public lianxixixi(String pinpai,String jixing,double price,double yh,double yxrj,double syyl){
this.pinpai=pinpai;
this.jixing=jixing;
this.price=price;
this.yh=yh;
this.yxrj=yxrj;
this.syyl=syyl;
}
public void show(){
System.out.println("品牌"+pinpai);
System.out.println("车型"+jixing);
System.out.println("价格"+price);
System.out.println("油耗"+yh);
System.out.println("里程"+lc);
System.out.println("油箱容积"+yxrj);
System.out.println("剩余油量"+syyl);
}
public void run(double lc){
syyl=syyl-(lc/100)*yh;
if(syyl<10){
System.out.println("再开，一会就得车开你了！");
}else{
System.out.println(syyl);}
}
}
public class lianxixi2 {
public static void main(String[] args) {
lianxixixi li=new lianxixixi("比亚迪","F0",45000.0,7.0,60.0,59.0);
li.show();
li.run(1000);
}
}
1.static:静态的，可以用来修饰属性、方法、*代码块（或初始化块）、*内部类
2.
static修饰属性（类变量）:
* 1.由类创建的所有的对象，都共用这一个属性
* 2.当其中一个对象对此属性进行修改，会导致其他对象对此属性的一个调用。vs 实例变量（非static修饰的属性，各个对象各自拥有一套副本）
* 3.类变量随着类的加载而加载的，而且独一份
* 4.静态的变量可以直接通过“类.类变量”的形式来调用
* 5.类变量的加载是要早于对象。所以当有对象以后，可以“对象.类变量”使用。但是"类.实例变量"是不行的。
* 6.类变量存在于静态域中。
*
* static修饰方法（类方法）:
* 1.随着类的加载而加载，在内存中也是独一份
* 2.可以直接通过“类.类方法”的方式调用
* 3.内部可以调用静态的属性或静态的方法，而不能调用非静态的属性或方法。反之，非静态的方法是可以调用静态的属性或静态的方法
* >静态的方法内是不可以有this或super关键字的！
* 注：静态的结构(static的属性、方法、代码块、内部类)的生命周期要早于非静态的结构，同时被回收也要晚于非静态的结构
Eclipse中编辑好了一个类，点击运行时出现如图所示的现象，现在编辑好的这个类并无错误，点击Proceed可正常运行。
按照字面意思就是，在这个“工程”中存在错误，打开工程列表----找到前边有红色叉叉的某个类，将错误去掉。
这个弹窗也就不会在出现了。
成员变量 局部变量 static