初始Java(二)

---

这是我参与更文挑战的第17天，活动详情查看： 更文挑战

---

封装

表现

1. 方法就是一个最基本封装体。
2. 类其实也是一个封装体。

作用

1. 提高了代码的复用性。
2. 隐藏了实现细节，还要对外提供可以访问的方式。便于调用者的使用。这是核心之一，也可以理解为就是封装的概念。
3. 提高了安全性。

总结

1. 外界通过对象的方法来访问对象
2. 总结：类中不需要对外提供的内容都私有化，包括属性和方法。以后再描述事物，属性都私有化，并提供set、get方法对其进行访问。注意：私有仅仅是封装的体现形式而已。

继承

1. 继承分为单继承和多重继承
2. Java只支持类之间的单继承，多重继承要通过接口实现

多态

含义

对外一个接口，内部多种实现

分类

1. 运行时多态、编译时多态

实现

通过方法的重载实现编译时多态，通过类的继承性、方法重写以及晚联编技术实现运行时多态

类的定义

基本结构

1. 成员变量
2. 成员方法

完整格式

[public][abstract | final] class ClassName [extends SuperClassName]
										[implements TnterfaceNameList]{
    ...
}

//修饰符 public，abstract或final说明了类的属性
//extends 类继承
//implements 实现类

注意：变量和方法称为类的成员，但构造方法不是的类的方法，不称为类的成员

成员变量

基本格式

[public][protected][private][static][final][transient][volative] type varibleName;

//[public][protected][private]或者没有修饰费（缺省default） 访问权限
//static 来限制成员变量为类变量，没有则为实例变量
//final 来声明一个常量，被final修饰的常量，不能被修改值
//transient来声明一个暂时性变量，默认下都是永久保存的

成员方法

基本格式

[public][protected][private][static][final][abstract][native][synchronized] <return_type> <name> (<argument_list>)[throws<exception_list>]{
    ...
};

//[public][protected][private]或者没有修饰费（缺省default或package） 访问权限
//static 来限制成员方法为类方法
//abstract表明是抽象方法，没有实现体
//final 修饰的方法不能别重写
//native表明方法有其他语言实现
//synchronized用来控制多个并发线程对共享数据的访问。

可变参数列表Varargs

//格式:   类型...参数名
//类型后面的...表明，该参数在方法调用时将传递进来一个数组或者一个参数序列


public float avg(int...nums){
    int sum=0;
    for(int x:nums){
        sum+=x;
    }
    return (float)sum/nums.length;
}
public static void main(String args[]){
    avg(10,20,30);
} 
///这里不能直接运行，可以自己改一下，这里只是说明一下用法

方法重载

遵循原则

1. 方法的参数表必须不同，包括参数的类型和数量，以此区分不同的方法体；
2. 方法的返回类型、修饰符可以相同也可不同

this

this 是Java使用的一个特有意义的引用，指向当前对象本身

构造方法

Java中所有类都有构造方法，用来对类对象的初始化

定义格式

[public|protected|private] <class_name>([<argument_list>]){
    [<statements>]
    
    /**
  
    1. public任何类都能创建此类的实例对象
    2. protected 只有这个类的子类或者同包的类对其进行实例化
    3. 缺省（package|default）只有同包的类对其进行实例化
    4. private 不能被其他类实例化，这个类中可能有一个具有public权限的方法（factory方法），只有他们能构造对象并返回
  
    */

}

注意

1. 构造方法名必须与类名相同

2. 构造方法不能有返回值

3. 用户不能直接调用构造方法，只有用new实例化对象时自动调用。

4. 当用户没有写构造方法时，Java提供了默认的构造方法

   1. 数值型——0
   2. boolean——false
   3. char——‘\0’
   4. 对象——null

5. this([<argument_list>])是调用所在类的构造方法

访问控制

1. public——公开的
2. protected——受保护的
3. private——私有的
4. 缺省——默认的，也称default或者package；

修饰符\权限	同一个类	同一个包	子类	全局
private	√
default	√	√
protected	√	√	√
public	√	√	√	√

总结

1. 对于类的成员变量和成员方法可以定义上述4种访问级别，对于类（除内部类外）可以有public和缺省（default）两种
2. 同一个类的不同对象之间可以访问对方的private成员变量和成员方法。这说明访问控制是在类的级别是上而不是对象的级别上。

内部类

内部类做为外包类的一个成员使用

1内部类做为外包类的一个成员使用，可以访问外包类的所有成员，包括带static的静态成员以及private的私有成员

表示外包类和内部类和内部类方法中同名变量

public class Outer{
    private int size;
    public class Inner{
        private int size;
        public void doStuff(int size){
            size++;//局部变量
            this.size++;//内部类成员变量
            Outer.this.size++;//外包类成员变量
        }
    }
} 
/**
当内部类方法访问外包类的同名变量是采用格式 ： 外包类名.this.同名变量名
*/

外包类的语句块中定义内部类

当内部类在方法体中的语句块中定义时，其生命周期仅限于改语句块运行时，其中的局部变量需要用final修饰（即常值局部变量）才能在方法运行结束后仍然存在。

在外包类以外的其他类中访问内部类

1. 内部类的访问权限与普通类和接口不同，共有四种权限 public，protected，default和private。
2. 可以在外包类之外被访问的内部类，在被访问时要用完整的表示：外包类名.内部类名

特性

1. 内部类的类型只用于定义它的类或语句块之内，在外部引用它时，必须给出带有外包类名的完整名称，并且内部类的名字不许与外包类的名字相同；
2. *内部类可以访问**外包类**的static或实例成员变量；*
3. *内部类可以在成员方法中定义，该成员方法的局部变量或参数必须是final的才能被内部类使用；*
4. 内部类可以是抽象类或者接口，如果是接口，可以由其他内部类实现；
5. 内部类可以使用public,protected,default,private四种访问权限控制；
6. 内部类可以被声明为static(普通类是不阔以的)，这样的内部类就变成了顶层类，相当于把它放在外面，不再是嵌套的内部类，并且它的对象中将不包含指向外包类对象的指针，所以不能再引用外包类对象；
7. 只有顶层类可以声明static成员。如果内部类需要static成员，那么内部类必须声明为static类型，否则，一般内部类的成员不能被声明为static.

匿名类

本地类（局部类）和匿名类是两种类型的内部类

本地类：内部类在一个方法体中声明，就是局部类（内部类）；

匿名类：没有名字的本地类。

本地类采用常规的类声明，而匿名类在一个表达式中定义，它是一个表达式的一部分。匿名类要继承一个父类或者实现一个接口。匿名类定义的语法包括new运算符，所继承的父类或所实现接口的名称，用括号括起的构造方法参数（如果是实现接口，因为接口没有构造方法，则括号中内容为空）、匿名类的声明块，这个块中，允许出现方法声明，不允许出现语句。

匿名类的好处是可以使代码更简洁，当某个本地类只使用一次时，可以把它定义为匿名类。

Lambda表达式

语法

Lambda表达式	参数列表	箭头符号	表达式主体
实例	（int，int y）	->	x+y

    (int x,int y)->x+y //以整数x,y两个为参数，返回x+y的值
    ()->42//无参数返回42
    (String s) ->{System.out.println(s);}/*不返回任何信息*/
    

Lambda替代匿名类

如果匿名类很简单，只包含一个方法的接口，