2021-01-13

面向对象
面向对象和面向过程的区别；
面向过程：
优点：性能比面向对象高，因为类调用时需要实例化，开销比较大，比较消耗资源;比如单片机、嵌入式开
发、Linux/Unix等一般采用面向过程开发，性能是最重要的因素。
缺点：没有面向对象易维护、易复用、易扩展。
面向对象：
优点：易维护、易复用、易扩展，由于面向对象有封装、继承、多态性的特性，可以设计出低耦合的系统，
使系统更加灵活、更加易于维护
缺点：性能比面向过程低。

public class Student{
public void who(){
return name;
}
private String name;//成员变量---属性
public void eat(){
int time=123;//局部变量
}
}

成员变量定义在类中，整个类中都能访问，和具体的定义位置无关。
局部变量定义在方法、语句、局部代码块中，只在所属的区域中有效，而且必须是先定义后使用，必须是先赋初值后使用。
成员变量存在于堆内存的对象中，堆内存中的对象大小可以任意，并允许在运行时进行调整。所以访问查找的效率比较低。
局部变量存在与栈内存的方法中，可以快速定位，但是大小是限定的。
成员变量随着对象的创建而存在，随着对象的表示而消失。局部变量随着所属区域的执行而存在，随着所属区域的结束而释放。
成员变量都有默认初始化值；局部变量没有默认初始化值。

封装三大好处；
良好的封装能够减少耦合。
类内部的结构可以自由修改。
可以对成员进行更精确的控制。
隐藏信息，实现细节类定义规则：要求类内高内聚，类间弱耦合。
封装确实可以使容易地修改类的内部实现，而无需修改使用了该类的客户代码。
限定类；

public class A{ //外部类
class B{} //这个类定义在类A中，所以叫做内部类
}

public class A{} 外部的独立类上可以使用的范围限定词有public和默认两种；内部类可以使用4大范围限定词中的
任意一个。
在一个.java文件中可以定义无数个class，但是只能定义一个public class，而且要求文件名称和public class类名称必须一致，包括大小都必须一致
public类可以在任意包中进行引用，没有范围限定词的class则只能在同包中访问。
如果类位于默认包中，则只能同包访问，其它位置不能访问【不管是public class或者默认 class】。
属性上的范围限定词
public 表示到处可见；
protected表示同包或者子类中可见；
默认表示同包可见；
private当前类内可见；

public class B1 {
public int ab1; //公共属性
}
B1 aa=new B1();
System.out.println(aa.ab1);

public class B1 {
protected String ab2;
}
//同包中可以直接访问，不同包中不能直接访问，但是子类中可以方法
B1 b=new B1();
System.out.println(b.ab2);
//子类，不同包
public class T extends B1{
public void pp() {
System.out.println(ab2); ///可以访问
}
public static void main(String[] args) {
B1 aa=new B1();
System.out.println(aa.ab2); //语法报错，不能访问
}
}
public class B1 {
double ab3;
}
//同包可以直接访问
B1 b=new B1();
System.out.println(b.ab3);
//不同包
public class T extends B1{
public void pp() {
System.out.println(ab3);//语法报错
}
public static void main(String[] args) {
B1 aa=new B1();
System.out.println(aa.ab3); //语法报错
}
}

方法上的限定词

public class A{
public void pp(){} //public就是范围限定词，其中可以使用4个中任何一个
}

同属性上的范围限定词一致；
public 表示到处可见；
protected表示同包或者子类中可见处可见；
默认表示同包可见；
private当前类内可见；
封装特点；
隔离变量。一般建议对于属性采用:私有属性，共有的get/set方法的形式进行定义；

public class B1 {
//私有属性
private String name;
private int age;
//共有的get/set方法，get方法称为读取器，set方法称为设置器
public int getAge() {//如果手写方法请注意命名规则
return age;
}
public void setAge(int age) {//可以添加验证逻辑
if(age>0 && age<18)
this.age = age;
else this.age=0;
}
public void setName(String name) {
this.name = name;
}
}

不是所有的属性都有get/set方法，取决于是否允许读写;允许读则只有get，没有set；如果只允许写，则只有set，没有get
针对boolean类型，不是Boolean类型的特殊命名规则。

public class B1 {
//私有属性
```java
private boolean sex;
//共有的get/set方法，get方法称为读取器，set方法称为设置器
public boolean isSex() { //注意get方法的命名，如果需要生成get方法可以使用Boolean来声
明
return sex;
}
public void setSex(boolean sex) {
this.sex = sex;
}
}

构造函数

构造函数是一种特殊的方法。主要用来在创建对象时初始化对象，即为对象成员变量赋初始值，总与new运算符一
起使用在创建对象的语句中。
一个类可以有多个构造函数 ，可根据其参数个数的不同或参数类型的不同来区分它们，即构造函数的重载
不算成员方法
使用语法可创建对象： new 构造函数();

public class B1 {
//方法名称和类名称一致，包括大小写
//方法没有返回值类型的声明
public B1() {}
public B1(int k) {}
//在一个类中允许方法同名【方法重载】，要求参数不同：类型、个数、顺序【参数类型不同】
public int B1(){}//从语法的角度上说是正确的，同时可以直接调用，不是构造器
}
//构造器方法不能直接调用，只能通过new运算符间接调用，例如new B1()调用无参构造器。

、public class A1 {
public A1() {//构造器中可以有return语句，但是不能return任何值
System.out.println("no argument constructor..");
}
public void A1() { //因为有返回值类型声明，所以不是构造器，是普通的成员方法
System.out.println("no argument method...");
}
}
//调用
A1 aa=new A1();//调用无参构造
aa.A1();//调用A1方法

构造函数特点；

函数名与类名相同，包括大小写
不用定义返回值类型，没有具体的返回值，但不用写void
一个类可以有多个不同的构造器，但是参数一定不能相同
构造器不能直接调用，总是和new运算符一起被调用
在构造函数前面加上返回值就只是一般函数了，不是构造器。
public class Student{
private String name;
private int age;
//出现了2个同名的name变量，一个成员变量，一个局部变量。可以使用this进行区分，this.name标识成
员变量，直接使用name表示局部变量。
public Student(String name,int age){
this.name=name;
this.age=age;
System.out.println(name);//按照就近原则，这个name用于指代局部变量
}
}
//调用
Student s1=new Student("xiaozeng",18); //如果类中定义了多个构造器，具体执行哪个构造器，是按照
参数类型进行最佳匹配
----
public class A1 {
public A1() {
System.out.println("no argument");
}
public A1(String a1) {
System.out.println("String");
}
public A1(String a1,short b1) {
System.out.println("string short");
}
public A1(String a1,int b1) {
System.out.println("string int");
}
public static void main(String[] args) {
A1 aa=new A1("123",(short)12);
}
}

使用下列语法可创建对象： new 构造函数();
当使用new运算符时自动进行调用，但是构造方法不能直接调用
关键字 new 通常称为创建运算符，用于分配对象内存，并将该内存初始化为缺省值
成员变量有默认值，局部变量如果不赋值则没有默认值
简单类型中的数值类型默认为0，char类型默认’\0’，boolean类型默认false
引用类型默认null
一旦 new 完成分配和初始化内存，它就将调用构造函数来执行对象初始化。
当定义Java类时没有定义构造器，则Java自动为类自动提供无参构造器, 将成员变量的值初始化为缺省值。

public class A{}//没有定义构造器，则系统自动提供一个无参的默认构造器
//构建对象
A a=new A()

一旦创建了自己的构造函数，缺省的构造函数将不复存在。

public class A{
public A(int k){}
}
//构建对象
A a=new A();//语法错误，因为A类中没有无参构造器，解决方法则是在class A中添加代码public A(){}

;

总结
用面向对象的构造函数做以前的练习题作用很大。注意语法。