【学懂Java】（四）面向对象编程-3

一.代码块

1.概念

使用”{}”括起来的一段代码

2.分类

根据位置可分类

普通代码块：

定义在方法中的使用{}括起来的代码

public class CodeBlockDemo {
    public void test(){
        System.out.println("test");{
            System.out.println("测试");
        }
    }

    public static void main(String[] args) {
        CodeBlockDemo codeBlockDemo = new CodeBlockDemo();//因为test是非static类型，所以不能在static的main里直接调用
        codeBlockDemo.test();{
            System.out.println("main");
        }
    }
}

构造代码块：

直接写在类中，用{}括起来的代码

public class CodeBlockDemo {
    {
        System.out.println("构造代码块");
    }
    public void test(){
        System.out.println("test");{
            System.out.println("测试");
        }
    }

    public static void main(String[] args) {
        CodeBlockDemo codeBlockDemo = new CodeBlockDemo();
        codeBlockDemo.test();{
            System.out.println("main");
        }
    }
}

通过反编译工具我们发现它将这段代码加在了构造方法中，在创建对象时默认调用了方法进行初始化，因此先打印了构造代码块

每次代码运行的时候会将构造代码块中的代码添加到每个构造方法前面，当使用this()时不会添加例如

public class CodeBlockDemo {

    int a;
    int b;
    public CodeBlockDemo(){
        System.out.println("构造方法");
    }

    public  CodeBlockDemo(int a){
        this.a=a;
    }

    public CodeBlockDemo(int a,int b){
        this(a);
        this.b=b;
    }

    {
        System.out.println("构造代码块");
    }
    public void test(){
        System.out.println("test");{
            System.out.println("测试");
        }
    }

    public static void main(String[] args) {
        CodeBlockDemo codeBlockDemo = new CodeBlockDemo();
        codeBlockDemo.test();{
            System.out.println("main");
        }
    }
}

反编译得

静态代码块：

使用static声明的代码块,在程序载入的时候优先执行（意味着不需要创建对象也会执行）

• 数据库连接等其他需要准备好的代码会放在static中

public class CodeBlockDemo {

    int a;
    int b;

    static {
        System.out.println("静态代码块");
    }

    public CodeBlockDemo(){
        System.out.println("构造方法");
    }

    public  CodeBlockDemo(int a){
        this.a=a;
    }

    public CodeBlockDemo(int a,int b){
        this(a);
        this.b=b;
    }

    {
        System.out.println("构造代码块");
    }
    public void test(){
        System.out.println("test");{
            System.out.println("测试");
        }
    }

    public static void main(String[] args) {
        CodeBlockDemo codeBlockDemo = new CodeBlockDemo();
        codeBlockDemo.test();{
            System.out.println("main");
        }
    }
}

同步代码块：

多线程的时候会使用，用来给分享空间进行加锁操作

​​http://mashibing.com​​

北京马士兵教育

公众号：马士兵《 Java系列课程》

二.package

就是包，对应到文件就是多级管理目录

1.解决问题

• 文件同名问题
• 为了方便管理类，将具体处理功能的代码放到同一个目录下

2.使用

一般定义package会放置在Java文件的第一行

完全定义名：包名+类名

3.JDK中的主要包

• java.lang（不需要手动导入）

• 包含一些Java语言的核心类，如String、Math、Integer、System和Thread，提供常用功能。

• java.awt

• 包含了构成抽象窗口工具集（abstract window toolkits）的多个类，这些类被用来构建和管理应用程序的图形用户界面(GUI)。

• java.net

• 包含执行不网络相关的操作的类。

• java.io

• 包含能提供多种输入/输出功能的类。

• java.util

• 包含一些实用工具类，如定义系统特性、使用不日期日历相关的函数。

4.import

当需要引入非lang包的其他java类的时候，需要使用import，否则每次在使用某个类的时候都需要将类的完全限定名写上

注意：当一个java文件中需要使用多个同名的类时，只能import一个，其余的用完全限定名

用法：

• import java.包名.类名:导入具体的类，推荐使用
• import 包名.*：导入当前包的所有类

静态导包：

当需要使用一个或某个类的多个方法时，但又不想重复写类名时，可以使用静态导包。

import static java.lang.Math.*
...
System.out.println(sqrt(2));
System.out.println(Math.sqrt(2));
//两者效果一样

 三.封装encapsulation(面向对象四大特征)

1.引入

package com.ak27;
public class Dog {
    String name;
    int age;
    String color;
    public Dog(){

    }
    public Dog(String name,int age,String color){
        this.age=age;
        this.color=color;
        this.name=name;
    }
    public void eat(){
        System.out.println("eating meat");
    }

    public void play(){

        System.out.println("basketball");
    }
    public void show(){
        System.out.println("name:"+this.name);
        System.out.println("age:"+this.age);
        System.out.println("color:"+this.color);
    }
}

package com.ak27;
public class DogTest {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.name="旺财";
        dog.age=-11;
        dog.color="black";
        dog.show();
    }
}

​​dog.age=-11;​​如果任何一个处理类都可以直接对Dog进行赋值操作，那么当值不正确的时候，可能会产生额外结果。如何在赋值的同时添加逻辑判断------封装。

package com.ak27;

public class Dog {
    String name;
    private int age;//访问修饰符保障不是谁都可以访问赋值
    String color;
    public Dog(){
    }
    public Dog(String name,int age,String color){
        this.age=age;
        this.color=color;
        this.name=name;
    }
/*------------------------封装 --------------------------*/
    public void setAge(int age){
        if(age>0){
            this.age = age;
        }else{
            System.out.println("输入年龄不规范");
        }
    }
/*------------------------------------------------------*/
    public void eat(){
        System.out.println("eating meat");
    }
    public void play(){

        System.out.println("basketball");
    }
    public void show(){
        System.out.println("name:"+this.name);
        System.out.println("age:"+this.age);
        System.out.println("color:"+this.color);
    }
}

package com.ak27;
public class DogTest {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.name="旺财";
        //int age = -12;
        dog.setAge(-11);
        dog.color="black";
        dog.show();
    }
}

2.概念

将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问

3.作用

使用封装可以保障数据的规范，不符合规范的数据将无法进行操作。

4.好处

1.隐藏类的内部实现细节

2.只能通过提供的方法进行访问，其他无法访问

3.可以根据需求添加复杂的逻辑判断语句

4.方便修改实现

5.总结

面向对象的封装（狭义）：

• 将类中的属性设置为私有属性，提供共有的外部方法程序进行调用，可以实现丰富的细节操作

广义的封装：

• 可以将完成特点功能的代码块封装成一个方法，供不同的程序进行调用

我们程序设计要追求“高内聚，低耦合”。

高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；

低耦合 ：仅暴露少量的方法给外部使用。

package com.ak27;

public class Dog {
    private String name;
    private int age;
    private String color;

    public Dog(){
    }
    public Dog(String name,int age,String color){
        this.age=age;
        this.color=color;
        this.name=name;
    }

    public void setAge(int age){
        if(age>0){
            this.age = age;
        }else{
            System.out.println("输入年龄不规范");
        }
    }

    public int getAge(){
        return this.age;
    }

    public void setName(String name){
        this.name=name;
    }

    public String getName(){
        return this.name;
    }

    public void setColor(String color){
        this.color=color;
    }

    public String getColor(){
        return this.color;
    }

    public void eat(){
        System.out.println("eating meat");
    }

    public void play(){

        System.out.println("basketball");
    }

    public void show(){
        System.out.println("name:"+this.name);
        System.out.println("age:"+this.age);
        System.out.println("color:"+this.color);
    }
}

package com.ak27;

public class DogTest {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.setName("旺财");
        dog.setAge(12);
        dog.setColor("Black");
        System.out.println(dog.getAge());
        System.out.println(dog.getName());
        System.out.println(dog.getColor());
        dog.show();
    }
}

四.Java中明确定义了访问权限

1.限制访问

• public:共有的

• 当前项目的所有类都可以访问

• protected：受保护的

• 可以被当前类访问，可以被当前包访问，也可以被子类访问

• default：默认权限

• 默认权限，可以被当前类访问，可以被当前包访问

• private：私有权限

• 只能被当前类访问

2.封装要点中的权限设置

类的属性的处理:

• 一般使用private. (除非本属性确定会让子类继承)
• 提供相应的get/set方法来访问相关属性. 这些方法通常是public，从而提供对属性的读取操作。 （注意：boolean变量的get方法是用：is开头!）

方法的属性的处理:

• 一些只用于本类的辅助性方法可以用private，
• 希望其他类调用的方法用public

3.利用权限了解值传递

当方法的参数值时基本数据类型的时候，不会改变原来的值

当方法的参数值是引用类型的时候，如果改变了该引用类型的值，会改变原来的对象的值

package com.ak27;

public class Change {
    public static void test(Point point){
        int x = point.getX();
        int y = point.getY();
        point.setX(y);
        point.setY(x);
    }

    public static void main(String[] args) {
        Point point =new Point(2,3);
        test(point);
        System.out.println(point.getX());
        System.out.println(point.getY());
    }
}

package com.ak27;

public class Point {
    private int x;
    private int y;

    public Point(int x,int y){
        this.x=x;
        this.y=y;
    }

    public void setX(int x) {
        this.x=x;
    }

    public int getX() {
        return x;
    }


    public void setY(int y){
        this.y=y;
    }

    public int getY(){
        return y;
    }
}