java 基础概念3

在Java中，声明一个方法的具体语法格式如下：
修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2,．．．．．．){ 
执行语句
……… 
return 返回值;
}


在Java中，声明一个方法的具体语法格式如下：
修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2,．．．．．．){ 
执行语句
……… 
return 返回值;
}


需要特别注意的是，方法中的“参数类型 参数名1，参数类型 参数名2”被称作参数列表，
它用于描述方法在被调用时需要接收的参数，如果方法不需要接收任何参数，则参数列表为空，
即()内不写任何内容。方法的返回值必须为方法声明的返回值类型，如果方法中没有返回值，

返回值类型要声明为void，此时，方法中return语句可以省略。

方法调用图解

从上图中可以看出，在程序运行期间，参数x和y相当于在内存中定义的两个变量。
当调用getArea()方法时，传入的参数3和5分别赋值给变量x和y，
并将x*y的结果通过return语句返回，整个方法的调用过程结束，变量x和y被释放。

在Java中，声明一个方法的具体语法格式如下：
修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2,．．．．．．){ 
执行语句
……… 
return 返回值;
}


在Java中，声明一个方法的具体语法格式如下：
修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2,．．．．．．){ 
执行语句
……… 
return 返回值;
}


需要特别注意的是，方法中的“参数类型 参数名1，参数类型 参数名2”被称作参数列表，
它用于描述方法在被调用时需要接收的参数，如果方法不需要接收任何参数，则参数列表为空，
即()内不写任何内容。方法的返回值必须为方法声明的返回值类型，如果方法中没有返回值，
返回值类型要声明为void，此时，方法中return语句可以省略。


方法调用图解


从上图中可以看出，在程序运行期间，参数x和y相当于在内存中定义的两个变量。
当调用getArea()方法时，传入的参数3和5分别赋值给变量x和y，
并将x*y的结果通过return语句返回，整个方法的调用过程结束，变量x和y被释放。


方法的重载 
Java允许在一个类中定义多个名称相同的方法，但是参数的类型或个数必须不同，这就是方法的重载。


public class MethodDemo03 {
public static void main(String[] args) {
// 下面是针对求和方法的调用
int sum1 = add(1, 2);
int sum2 = add(1, 2, 3);
double sum3 = add(1.2, 2.3);
// 下面的代码是打印求和的结果
System.out.println("sum1=" + sum1);
System.out.println("sum2=" + sum2);
System.out.println("sum3=" + sum3);
}


// 下面的方法实现了两个整数相加
public static int add(int x, int y) {
return x + y;
}
// 下面的方法实现了三个整数相加
public static int add(int x, int y, int z) {
return x + y + z;
}
// 下面的方法实现了两个小数相加
public static double add(double x, double y) {
return x + y;
}
}
上述代码中定义了三个同名的add()方法，它们的参数个数或类型不同，从而形成了方法的重载。
在main()方法中调用add()方法时，通过传入不同的参数便可以确定调用哪个重载的方法，
如add(1,2)调用的是两个整数求和的方法。值得注意的是，方法的重载与返回值类型无关，
它只有两个条件，一是方法名相同，二是参数个数或参数类型不相同。
重载方法参数必须不同：
参数个数不同，如method(int x)与method(int x,int y)不同
参数类型不同，如method(int x)与method(double x)不同g
参数顺序不同，如method(int x,double y)与method(double x,int y)不同
重载只与方法名与参数类型相关与返回值无关
如void method(int x)与int method(int y)不是方法重载，不能同时存在
重载与具体的变量标识符无关
如method(int x)与method(int y)不是方法重载，不能同时存在


参数传递
参数传递，可以理解当我们要调用一个方法时，我们会把指定的数值，传递给方法中的参数，
这样方法中的参数就拥有了这个指定的值，可以使用该值，在方法中运算了。这种传递方式，我们称为参数传递。
在这里，定义方法时，参数列表中的变量，我们称为形式参数
调用方法时，传入给方法的数值，我们称为实际参数

将现实生活中的事物抽象成了代码。
这时，我们可以使用自定义的数据类型（类）来描述（映射）现实生活中的事物。
类，它是引用数据类型，与之前学习的所有引用数据类型相同，自定义类也是一种数据类型。
只是自定义类型并非Java为我们预先提供好的类型，
而是我们自己定义的一种引用数据类型用来描述一个事物。


类的定义格式
创建java文件，与类名相同
public class 类名{
数据类型  属性名称1；
数据类型  属性名称2；
…
}


导包：我们将所有的类放到同一个文件夹下，可以避免导包。
创建对象：数据类型  变量名 = new 数据类型();
调用方法：目前我们定义的自定义类不涉及方法，只是属性


public class Test {
public static void main(String[] args) {
//定义了一个Phone类型的变量p
Phone p = new Phone();
/*
* 通过p,使用Phone中的属性
*/
//访问p中的brand品牌属性
p.brand = "苹果6s";[为p中brand属性赋值为”苹果6s”]
//访问p中的color颜色属性
p.color = "白色";[为p中color属性赋值为”白色”]
//访问p中的size尺寸大小属性
p.size = 5.5;[为p中size属性赋值为5.5]


System.out.println("手机品牌为" + p.brand[使用p中brand属性值参与运算]);
System.out.println("手机颜色为" + p.color[使用p中color属性值参与运算]);
System.out.println("手机尺寸大小为" + p.size[使用p中size属性值参与运算]);
}
}


ArrayList集合是程序中最常见的一种集合，它属于引用数据类型（类）。
在ArrayList内部封装了一个长度可变的数组，当存入的元素超过数组长度时，
ArrayList会在内存中分配一个更大的数组来存储这些元素，
因此可以将ArrayList集合看作一个长度可变的数组。


导包：import java.util.ArrayList;
创建对象：与其他普通的引用数据类型创建方式完全相同，但是要指定容器中存储的数据类型：
ArrayList<要存储元素的数据类型> 变量名 = new ArrayList<要存储元素的数据类型>();
?集合中存储的元素，只能为<>括号中指定的数据类型元素；
“<要存储元素的数据类型>”中的数据类型必须是引用数据类型，不能是基本数据类型


基本数据类型 对应的引用数据类型表示形式
byte Byte
short Short
Int Integer
long Long
float Float
double Double
char Character
boolean Boolean


ArrayList集合提供的一些常用方法
方法声明 功能描述
boolean add（Object obj） 将指定元素obj追加到集合的末尾
Object get（int index） 返回集合中指定位置上的元素
int size（） 返回集合中的元素个数


import java.util.ArrayList;
public class ArrayListDemo01 {
public static void main(String[] args) {
// 创建ArrayList集合
ArrayList<String> list = new ArrayList<String>();
// 向集合中添加元素
list.add("stu1");
list.add("stu2");
list.add("stu3");
list.add("stu4");
// 获取集合中元素的个数
System.out.println("集合的长度：" + list.size());
// 取出并打印指定位置的元素
System.out.println("第1个元素是：" + list.get(0));
System.out.println("第2个元素是：" + list.get(1));
System.out.println("第3个元素是：" + list.get(2));
System.out.println("第4个元素是：" + list.get(3));
}
}
ArrayList集合相当于是一个长度可变的数组，所以访问集合中的元素也是采用索引方式访问，
第一个元素存储在索引0的位置，第二个元素存储在索引1的位置，依次类推。


通过集合遍历，得到集合中每个元素，这是集合中最常见的操作
 1mport java.util.ArrayList;
 2public class ArrayListDemo02 {
 3 public static void main(String[] args) {
 4 //创建ArrayList集合
 5 ArrayList<Integer> list = new ArrayList<Integer>();
 6 //添加元素到集合
 7 list.add(13);
 8 list.add(15);
 9 list.add(22);
 10 list.add(29);
 11 //遍历集合
 12 for (int i = 0; i < list.size()[获取集合中元素的个数]; i++) {
 13 //通过索引，获取到集合中每个元素
 14 int n = list.get(i)[获取集合中指定位置上的元素值];
 15 System.out.println(n);
 16 }
 17 }
 上述代码中，第5行定义了一个可以存储int元素的集合；第7-10行，实现将int类型数值存储到集合中；
 第12-16行，实现遍历集合元素。这里要强调一点，get方法返回值的类型为集合中元素的类型。
 
 ArrayList集合提供的一些常用方法，如下表：
方法声明 功能描述
boolean add（int index,  Object obj） 将指定元素obj插入到集合中指定的位置
Object remve（int index） 从集合中删除指定index处的元素，返回该元素
void clear（） 清空集合中所有元素
Object set（int index, Object obj） 用指定元素obj替代集合中指定位置上的元素
boolean add（int index,  Object obj）
功能：在集合中指定index位置，添加新元素obj
功能说明：假设集合list中有元素[“java”,“javaEE”]，当使用add(1，“javaWeb”)后，集合list中的元素为[“java”,“javaWeb”,“JavaEE”]。
Object set（int index, Object obj）
功能：用指定元素obj替代集合中指定index位置的元素
功能说明：假设集合list中有元素[“java”,“javaEE”]，当使用set(0，“javaWeb”)后，集合list中的元素为[“javaWeb”,“JavaEE”]。
Object remove（int index）
功能：从集合中删除指定index处的元素，返回该元素
功能说明：假设集合list中有元素[“java”,“javaEE”]，当使用remove(0)后，集合list中的元素为[“JavaEE”]，返回值为“java”。
void clear（）
功能：清空集合中所有元素
功能说明：假设集合list中有元素[“java”,“javaEE”]，当使用clear()后，集合list中的元素为空[]。

 American Standard Code for Information Interchange，美国标准信息交换代码.
  在计算机中，所有的数据在存储和运算时都要使用二进制数表示, a、b、c、d这样的52个字母
（包括大写）、以及0、1等数字还有一些常用的符号, 在计算机中存储时也要使用二进制数来表示，
而具体用哪些二进制数字表示哪个符号，当然每个人都可以约定自己的一套（这就叫编码），
而大家如果要想互相通信而不造成混乱，那么大家就必须使用相同的编码规则，
于是美国有关的标准化组织就出台了ASCII编码，统一规定了上述常用符号用哪些二进制数来表示。


数字0-9对应ASCII编码十进制为48-57, 字母a-z对应ASCII编码十进制为97-122，
字母A-Z对应ASCII编码十进制为65-90


利用for循环打印 利用for循环打印 26个大写字母与26个小写字母
public class Test04 {
public static void main(String[] args) {
char da = 'A';
char xiao = 'a';
for (int i = 0; i < 26; i++) {
System.out.println("大写字母 "+da+" ,小写字母 "+xiao);
da++; //更新大写字母值
xiao++; //更新小写字母值
}
}
}


?类与对象
?类，用于描述多个对象的共同特征，它是对象的模板。
?对象，用于描述现实中的个体，它是类的实例。
?类的定义：使用关键字class来定义java中的类
格式：
class 类名 {
//属性
数据类型 变量名; …
//方法
修饰符 返回值类型 方法名(参数){   }
…
}
创建对象：
格式：
类名 对象名 = new 类名();
封装（private关键字）
封装，把对象的属性与方法的实现细节隐藏，仅对外提供一些公共的访问方式
封装的体现：
变量:使用 private 修饰，这就是变量的封装
方法:也是一种封装，封装了多条代码
类： 也是一种封装，封装了多个方法
private关键字，私有的意思
它可以用来修饰类中的成员(成员变量，成员方法)
private的特点：
private修饰的成员只能在当前类中访问，其他类中无法直接访问
this关键字
this关键字，本类对象的引用
this是在方法中使用的，哪个对象调用了该方法，那么，this就代表调用该方法的对象引用
this什么时候存在的？当创建对象的时候，this存在的
this的作用：用来区别同名的成员变量与局部变量（this.成员变量）
public void setName(String name) {
this.name = name;
}


在Java中，类的继承是指在一个现有类的基础上去构建一个新的类，构建出来的新类被称作子类，
现有类被称作父类，子类会自动拥有父类所有可继承的属性和方法。


继承的好处：
1、继承的出现提高了代码的复用性，提高软件开发效率。
2、继承的出现让类与类之间产生了关系，提供了多态的前提。
在类的继承中，需要注意一些问题，具体如下：
1、在Java中，类只支持单继承，不允许多继承，也就是说一个类只能有一个直接父类，例如下面这种情况是不合法的。
class A{} 
     class B{}
     class C extends A,B{}  // C类不可以同时继承A类和B类
2、多个类可以继承一个父类，例如下面这种情况是允许的。
     class A{}
     class B extends A{}
     class C extends A{}   // 类B和类C都可以继承类A
3、在Java中，多层继承是可以的，即一个类的父类可以再去继承另外的父类，例如C类继承自B类，而B类又可以去继承A类，
这时，C类也可称作A类的子类。下面这种情况是允许的。
     class A{}
     class B extends A{}   // 类B继承类A，类B是类A的子类
     class C extends B{}   // 类C继承类B，类C是类B的子类，同时也是类A的子类
4、在Java中，子类和父类是一种相对概念，也就是说一个类是某个类父类的同时，也可以是另一个类的子类。
例如上面的这种情况中，B类是A类的子类，同时又是C类的父类。


局部变量和成员变量区别
区别一：定义的位置不同
定义在类中的变量是成员变量
定义在方法中或者{}语句里面的变量是局部变量
区别二：在内存中的位置不同
成员变量存储在对内存的对象中
局部变量存储在栈内存的方法中
区别三：声明周期不同
成员变量随着对象的出现而出现在堆中，随着对象的消失而从堆中消失
局部变量随着方法的运行而出现在栈中，随着方法的弹栈而消失
区别四：初始化不同
成员变量因为在堆内存中，所有默认的初始化值
局部变量没有默认的初始化值，必须手动的给其赋值才可以使用。


封装，它也是面向对象思想的特征之一。面向对象共有三个特征：封装，继承，多态。
1、方法就是一个最基本封装体。
2、类其实也是一个封装体。
从以上两点得出结论，封装的好处：
1、提高了代码的复用性。
2、隐藏了实现细节，还要对外提供可以访问的方式。便于调用者的使用。这是核心之一，也可以理解为就是封装的概念。
3、提高了安全性。


当在方法中出现了局部变量和成员变量同名的时候，那么在方法中怎么区别局部变量成员变量呢？
可以在成员变量名前面加上this.来区别成员变量和局部变量

程序中内存对象的创建使用过程
1、先执行main方法（压栈），执行其中的 Person p = new Person()；
2、在堆内存中开辟空间，并为其分配内存地址0x1234，紧接着成员变量默认初始化(age = 0)；
将内存地址0x1234赋值给栈内中的Person p 变量
3、继续执行p.setAge(30)语句，这时会调用setAge(int age)方法，
将30赋值为setAge方法中的“age”变量；执行this.age = age语句，将age变量值30 赋值给成员变量this.age为30；
4、setAge()方法执行完毕后（弹栈），回到main()方法，
执行输出语句System.out.println()，控制台打印p对象中的age年龄值。
上述代码中的 p.setAge(30)语句中，setAge(int age)方法中的this代表的就是p对象。

在Java中，类的继承是指在一个现有类的基础上去构建一个新的类，
构建出来的新类被称作子类，现有类被称作父类，
子类会自动拥有父类所有可继承的属性和方法。


重写需要注意的细节问题：
子类方法覆盖父类方法，必须要保证权限大于等于父类权限。
class Fu(){
void show(){}
    public void method(){}
}
class Zi() extends Fu{
public void show(){}  //编译运行没问题
    void method(){}      //编译错误
}
写法上稍微注意:必须一模一样:方法的返回值类型 方法名 参数列表都要一样。
总结：当一个类是另一个类中的一种时，可以通过继承，来继承属性与功能。
如果父类具备的功能内容需要子类特殊定义时，进行方法重写。


分析事物时，发现了共性内容，就出现向上抽取。会有这样一种特殊情况，
就是方法功能声明相同，但方法功能主体不同。那么这时也可以抽取，
但只抽取方法声明，不抽取方法主体。那么此方法就是一个抽象方法。


抽象类和抽象方法都需要被abstract修饰。抽象方法一定要定义在抽象类中。
2、抽象类不可以直接创建对象，原因：调用抽象方法没有意义。
3、只有覆盖了抽象类中所有的抽象方法后，其子类才可以创建对象。
否则该子类还是一个抽象类。
之所以继承抽象类，更多的是在思想，是面对共性类型操作会更简单。


继承：是指在一个现有类的基础上去构建一个新的类，构建出来的新类被称作子类，现有类被称作父类，
子类会自动拥有父类所有
继承的好处：可继承的属性和方法。

提高了代表的可维护性
提高了代码的复用性
让类与类之间产生了继承关系
继承的弊端：
类与类之间的耦合度过高
继承特点：
java中类只能够单继承，不能多继承，可以多层继承
class Yy extends Object {}
class Fu extends Yy{}
class Zi extends Fu {}
所有的类都直接或者间接的继承了 Object类，Object类称为祖宗类
继承的注意事项：
1，使用关键字 extends 让类与类之间 产生继承关系
2, 父类私有的成员，子类不能继承，因为根本看不到
3，不能为了继承某个功能而随意进行继承操作， 必须要符合 is a 的关系
苹果 is a 水果
男人 is a 人
狗   is a 人 ， 这种情况就不能继承了
继承中的成员变量关系：
不同名的变量：
子类直接继承使用
同名的变量：
默认访问的是子类自己的成员变量, 想访问父类中的同名变量，请使用 super.成员变量;
继承中的成员方法关系：
不同名的方法：
子类直接继承使用
同名的方法：
默认访问的是子类自己的成员方法，想访问父类中的同名方法，请使用 super.成员方法();
super:用来表示当前对象中包含的父类对象空间的引用
调用父类的成员变量：
super.成员变量;
调用方法的成员方法:
super.成员方法();
方法重写(override)：指 在子父类中，出现了方法声明相同的情况，也叫做方法覆盖，方法复写
方法重写的注意事项：
1，子类的方法声明要与父类相同
2, 子类要重写方法的方法，方法的权限修饰符不能比父类的更低
3, 父类私有的方法，子类不能够进行方法重写
方法重载(overload)：指 在同一个类中，多个方法名称相同，它们的参数列表不同(个数不同，数据类型不同)
抽象
抽象方法： 方法只有声明部分，没有方法体
抽象类： 包含抽象方法的类，一定是抽象类
      使用 abstract 修饰的类，是抽象类
抽象类的特点：  
1，抽象类与抽象方法都必须使用 abstract来修饰  
2，抽象类不能直接创建对象
3，抽象类中可以有抽象方法，也可以没有抽象方法
4，抽象类的子类
a，实现了抽象方法的具体类
b，抽象类